@@ -329,12 +329,18 @@
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/capture.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/frame_store.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/frame_store.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/input.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/input.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/keymap.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/keymap.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/pixel_format.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/pixel_format.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/render_node.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/render_node.cpp"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/session.h"
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/session.cpp")
            "${CMAKE_SOURCE_DIR}/src/platform/linux/qemu/session.cpp"
            "${CMAKE_SOURCE_DIR}/third-party/qemu-keycodemapdb/linux_to_qnum.cpp"
            "${CMAKE_SOURCE_DIR}/third-party/qemu-keycodemapdb/qnum_to_linux.cpp")
endif()
if(NOT ${CUDA_FOUND}

@@ -2233,6 +2233,14 @@
            The guest's sound is streamed too when QEMU plays it to D-Bus: start QEMU with
            `-audiodev dbus,id=snd0`, a sound device such as `-device intel-hda -device hda-output,audiodev=snd0`,
            and `-display dbus,audiodev=snd0`. Sunshine's audio sink settings don't apply to a VM.
            Keyboard, mouse and touch input go to the streamed console through QEMU's D-Bus input interfaces
            (gamepads still use virtual host devices). An absolute pointer such as `-device virtio-tablet-pci`
            works best; with a relative mouse (PS/2) Moonlight's absolute pointer positions only work while the
            guest shows a hardware cursor. Horizontal scrolling and text input aren't supported.
            Native touch (see [native_pen_touch](#native_pen_touch)) needs `-device virtio-multitouch-pci` in the VM;
            QEMU then sends mouse buttons to the touch device and drops wheel events, so add it only for touch-first
            guests. QEMU can't tell Sunshine whether that device exists: for a VM without it, disable
            native_pen_touch so Moonlight sends touches as mouse input. Pens always move the mouse.
            @note{Applies to Linux only.}</td>
    </tr>
    <tr>

@@ -15,17 +15,30 @@
// local includes
#include "src/platform/virtualhid_input.h"
#ifdef SUNSHINE_BUILD_QEMU
  #include "src/config.h"
#endif
using namespace std::literals;
namespace platf {
  platform_caps::caps_t get_capabilities() {
    platform_caps::caps_t caps = 0;
#ifdef SUNSHINE_BUILD_QEMU
    // with capture = qemu, touch and pen go to QEMU's MultiTouch or mouse, not to host devices
    const bool qemu = config::video.capture == "qemu";
    if (qemu && config::input.native_pen_touch) {
      caps |= platform_caps::pen_touch;
    }
#else
    const bool qemu = false;
#endif
    const auto runtime = virtualhid::create_runtime();
    if (!runtime) {
      return caps;
    }
    if (const auto &capabilities = runtime->capabilities(); !qemu && config::input.native_pen_touch && (capabilities.supports_touchscreen || capabilities.supports_pen_tablet)) {
    if (const auto &capabilities = runtime->capabilities(); config::input.native_pen_touch && (capabilities.supports_touchscreen || capabilities.supports_pen_tablet)) {
      caps |= platform_caps::pen_touch;
    }
    if (virtualhid::configured_gamepad_supports_controller_extensions()) {

@@ -64,6 +64,10 @@
#include "src/platform/common.h"
#include "vaapi.h"
#ifdef SUNSHINE_BUILD_QEMU
  #include "qemu/input.h"
#endif
#ifdef __GNUC__
  #define SUNSHINE_GNUC_EXTENSION __extension__
#else
@@ -545,7 +549,10 @@
   * @brief Restore Linux platform state after streaming stops.
   */
  void streaming_will_stop() {
#ifdef SUNSHINE_BUILD_QEMU
    // Nothing to do
    // the last client left: nothing it pressed may stay held in the VM
    qemu::release_all_inputs();
#endif
  }
  /**

@@ -15,6 +15,7 @@
// local includes
#include "frame_store.h"
#include "input.h"
#include "render_node.h"
#include "session.h"
#include "src/config.h"
@@ -92,6 +93,8 @@
    if (!conn.registration) {
      return std::nullopt;
    }
    // keyboard, mouse and touch go to the console being streamed
    set_capture_console(conn.session, console->id, conn.store);
    // QEMU sends the current surface right after registration
    if (conn.store->wait_for_frame(2s)) {

@@ -293,6 +293,7 @@
    cursor_state.x = x;
    cursor_state.y = y;
    cursor_state.visible = visible;
    mouse_set_count += 1;
    if (redraw && frame_width > 0) {
      touch_locked();
    }
@@ -332,6 +333,14 @@
      copy.pixels = cursor_state.pixels;
    }
    return copy;
  }
  std::optional<pointer_position_t> frame_store_t::pointer() const {
    std::lock_guard lock {mutex};
    if (mouse_set_count == 0) {
      return std::nullopt;
    }
    return pointer_position_t {cursor_state.x, cursor_state.y, mouse_set_count, cursor_state.visible};
  }
  void frame_store_t::disconnected() {

@@ -73,6 +73,16 @@
  };
  /**
   * @brief Guest pointer position reported by `MouseSet`.
   */
  struct pointer_position_t {
    std::int32_t x {0};  ///< Pointer X position in frame pixels.
    std::int32_t y {0};  ///< Pointer Y position in frame pixels.
    std::uint64_t sequence {0};  ///< Number of `MouseSet` calls so far; changes with every report.
    bool visible {false};  ///< Whether QEMU reported the cursor as shown.
  };
  /**
   * @brief Alpha-blend a cursor onto a B, G, R, X frame.
   *
   * @param cursor Cursor to draw; nothing happens when it isn't drawable.
@@ -207,6 +217,13 @@
     */
    [[nodiscard]] cursor_state_t cursor(std::uint64_t known_serial) const;
    /**
     * @brief Latest guest pointer position, for converting absolute input for a relative mouse.
     *
     * @return Position and report count, or nothing before the first `MouseSet`.
     */
    [[nodiscard]] std::optional<pointer_position_t> pointer() const;
  private:
    /**
     * @brief Resize the frame, logging size or transport changes.
@@ -269,5 +286,6 @@
    bool is_disconnected {false};  ///< Whether QEMU closed the listener connection.
    int logged_transport {-1};  ///< Transport of the last logged scanout: messages, map or DMABUF.
    cursor_state_t cursor_state;  ///< Latest guest cursor.
    std::uint64_t mouse_set_count {0};  ///< Number of `MouseSet` calls received.
    scanout_kind_e scanout_kind {scanout_kind_e::none};  ///< How the latest scanout arrived.
    bool is_disabled {false};  ///< Whether QEMU turned the display off since the last scanout.

@@ -1,0 +1,654 @@
/**
 * @file src/platform/linux/qemu/input.cpp
 * @brief Definitions for sending Moonlight keyboard, mouse and touch input to a QEMU VM.
 */
// class header include
#include "input.h"
// standard includes
#include <algorithm>
#include <atomic>
#include <cmath>
#include <ios>
#include <limits>
// local includes
#include "keymap.h"
#include "src/config.h"
#include "src/logging.h"
using namespace std::literals;
namespace qemu {
  namespace {
    constexpr int wheel_delta = 120;  ///< High-resolution scroll units per wheel step.
    constexpr auto reconnect_delay = 1s;  ///< Pause after a failed connection attempt.
    constexpr auto pointer_settle_time = 100ms;  ///< Motion pause after which `MouseSet` reports are trusted again.
    constexpr auto drop_log_interval = 5s;  ///< Minimum time between "not connected" logs.
    constexpr std::uint32_t pen_contact = std::numeric_limits<std::uint32_t>::max();  ///< Contact id used for the pen.
    /**
     * @brief The session and console the capture streams.
     */
    struct capture_binding_t {
      std::weak_ptr<session_t> session;  ///< Capture session.
      std::uint32_t console_id {0};  ///< Captured console.
      std::weak_ptr<frame_store_t> store;  ///< Frame store of the capture, for `MouseSet`.
    };
    std::mutex binding_mutex;  ///< Guards `binding`.
    capture_binding_t binding;  ///< Latest capture binding.
    std::atomic<std::uint64_t> binding_generation {0};  ///< Incremented when the captured session or console changes.
    std::mutex registry_mutex;  ///< Guards `inputs`.
    std::set<input_t *> inputs;  ///< Live inputs, for `release_all_inputs()`.
    /**
     * @brief Copy the capture binding.
     *
     * @return Binding and its generation.
     */
    std::pair<capture_binding_t, std::uint64_t> capture_binding() {
      std::lock_guard lock {binding_mutex};
      return {binding, binding_generation.load()};
    }
    /**
     * @brief Find the capture's frame store for a console.
     *
     * @param session Session the console belongs to.
     * @param console_id Console id.
     * @return The store, or nullptr when no capture runs on that console.
     */
    std::shared_ptr<frame_store_t> capture_store(const std::weak_ptr<session_t> &session, std::uint32_t console_id) {
      std::lock_guard lock {binding_mutex};
      const bool same_session = !binding.session.owner_before(session) && !session.owner_before(binding.session);
      if (!same_session || binding.console_id != console_id) {
        return nullptr;
      }
      return binding.store.lock();
    }
    /**
     * @brief Translate a Moonlight mouse button.
     *
     * @param button Moonlight button number.
     * @return QEMU button, or nothing for unknown buttons.
     */
    std::optional<mouse_button_e> qemu_button(int button) {
      switch (button) {
        case BUTTON_LEFT:
          return mouse_button_e::left;
        case BUTTON_MIDDLE:
          return mouse_button_e::middle;
        case BUTTON_RIGHT:
          return mouse_button_e::right;
        case BUTTON_X1:
          return mouse_button_e::side;
        case BUTTON_X2:
          return mouse_button_e::extra;
        default:
          return std::nullopt;
      }
    }
  }  // namespace
  void set_capture_console(const std::shared_ptr<session_t> &session, std::uint32_t console_id, const std::shared_ptr<frame_store_t> &store) {
    std::lock_guard lock {binding_mutex};
    const auto previous = binding.session.lock();
    if (previous != session || binding.console_id != console_id) {
      binding_generation += 1;
    }
    // a capture re-created after a mode change keeps the console: only the store changes
    binding = {session, console_id, store};
  }
  void release_all_inputs() {
    std::lock_guard lock {registry_mutex};
    for (auto input : inputs) {
      input->release_all();
    }
  }
  std::size_t input_count() {
    std::lock_guard lock {registry_mutex};
    return inputs.size();
  }
  input_t::input_t(std::string address):
      address {std::move(address)} {
    worker = std::thread([this]() {
      run();
    });
    std::lock_guard lock {registry_mutex};
    inputs.insert(this);
  }
  input_t::~input_t() {
    {
      std::lock_guard lock {registry_mutex};
      inputs.erase(this);
    }
    {
      std::lock_guard lock {mutex};
      stopping = true;
    }
    wake.notify_all();
    worker.join();
  }
  bool input_t::wait_for_console(std::chrono::milliseconds timeout) {
    std::unique_lock lock {mutex};
    const auto ready = [&]() {
      if (target && target->device->alive() && target->binding == binding_generation) {
        return true;
      }
      if (!connecting && !connect_requested) {
        connect_requested = true;
        next_attempt = {};
        wake.notify_all();
      }
      return false;
    };
    return ready() || wake.wait_for(lock, timeout, ready);
  }
  std::optional<bool> input_t::guest_absolute() {
    std::lock_guard lock {mutex};
    if (!target || !target->device->alive()) {
      return std::nullopt;
    }
    return target->device->is_absolute();
  }
  std::optional<std::pair<std::uint32_t, std::uint32_t>> input_t::console_size() {
    std::lock_guard lock {mutex};
    if (!target || !target->device->alive()) {
      return std::nullopt;
    }
    return std::pair {target->device->width(), target->device->height()};
  }
  bool input_t::flush(std::chrono::milliseconds timeout) {
    std::shared_ptr<console_input_t> device;
    {
      std::lock_guard lock {mutex};
      if (target) {
        device = target->device;
      }
    }
    return !device || device->flush(timeout);
  }
  console_input_t *input_t::device_locked() {
    if (target && target->device->alive()) {
      if (target->binding != binding_generation && !connecting && !connect_requested) {
        // the capture moved to another console or session; keep sending here until connected there
        connect_requested = true;
        wake.notify_all();
      }
      return target->device.get();
    }
    if (!connecting && !connect_requested) {
      connect_requested = true;
      wake.notify_all();
    }
    const auto now = std::chrono::steady_clock::now();
    if (now - last_drop_log >= drop_log_interval) {
      last_drop_log = now;
      BOOST_LOG(debug) << "qemu: not connected to a VM console yet; dropping input"sv;
    }
    return nullptr;
  }
  std::optional<input_t::target_t> input_t::connect() {
    auto [capture, generation] = capture_binding();
    auto session = capture.session.lock();
    auto console_id = capture.console_id;
    if (!session || !session->alive()) {
      // no stream yet: use the console output_name selects, like the capture will
      session = shared_session(address);
      if (!session) {
        return std::nullopt;
      }
      const auto vm = session->vm();
      auto console = find_console(vm, config::video.output_name);
      if (!console) {
        console = find_console(vm, "");
      }
      if (!console) {
        BOOST_LOG(error) << "qemu: VM ["sv << vm.name << "] has no graphical console for input"sv;
        return std::nullopt;
      }
      console_id = console->id;
    }
    auto device = session->open_input(console_id);
    if (!device) {
      return std::nullopt;
    }
    return target_t {std::move(device), session, generation};
  }
  void input_t::run() {
    std::unique_lock lock {mutex};
    while (true) {
      wake.wait(lock, [&]() {
        return stopping || connect_requested;
      });
      if (stopping) {
        break;
      }
      if (std::chrono::steady_clock::now() < next_attempt) {
        wake.wait_until(lock, next_attempt, [&]() {
          return stopping || std::chrono::steady_clock::now() >= next_attempt;
        });
        continue;
      }
      connect_requested = false;
      connecting = true;
      lock.unlock();
      auto connected = connect();
      lock.lock();
      connecting = false;
      if (!connected) {
        next_attempt = std::chrono::steady_clock::now() + reconnect_delay;
        wake.notify_all();
        continue;
      }
      std::optional<target_t> previous = std::move(target);
      if (previous && previous->device->alive()) {
        const bool same_console = previous->session.lock() == connected->session.lock() && previous->device->console_id() == connected->device->console_id();
        if (!same_console) {
          release_all_locked(*previous->device);
          pointer_x.reset();
          pointer_y.reset();
          pointer_sequence = 0;
        }
      } else {
        // a new VM: nothing we pressed exists there
        forget_state_locked();
        pointer_x.reset();
        pointer_y.reset();
        pointer_sequence = 0;
      }
      target = std::move(connected);
      wake.notify_all();
      // the previous console input waits for its pending replies when destroyed
      lock.unlock();
      previous.reset();
      lock.lock();
    }
    auto last = std::move(target);
    lock.unlock();
    last.reset();
  }
  void input_t::forget_state_locked() {
    pressed_keys.clear();
    pressed_buttons.clear();
    touch_contacts.clear();
    mouse_contact.reset();
    scroll_remainder = 0;
    motion_remainder_x = 0;
    motion_remainder_y = 0;
  }
  void input_t::release_all_locked(console_input_t &device) {
    for (const auto &[qnum, holders] : pressed_keys) {
      device.key(qnum, false);
    }
    for (auto button : pressed_buttons) {
      device.button(button, false);
    }
    for (const auto &[id, contact] : touch_contacts) {
      device.touch(touch_kind_e::cancel, contact.slot, contact.x, contact.y);
    }
    forget_state_locked();
  }
  void input_t::release_all() {
    std::lock_guard lock {mutex};
    if (target && target->device->alive()) {
      release_all_locked(*target->device);
    } else {
      forget_state_locked();
    }
  }
  void input_t::sync_guest_pointer_locked(const console_input_t &device) {
    const auto store = capture_store(target->session, device.console_id());
    if (!store) {
      return;
    }
    // a hidden cursor's position means nothing (QEMU reports 0,0 for virtio-gpu before the guest shows one)
    const auto pointer = store->pointer();
    if (!pointer || !pointer->visible || pointer->sequence == pointer_sequence) {
      return;
    }
    if (pointer_x && std::chrono::steady_clock::now() - last_relative_motion < pointer_settle_time) {
      return;
    }
    BOOST_LOG(verbose) << "qemu: guest pointer at "sv << pointer->x << ',' << pointer->y << " from MouseSet"sv;
    pointer_sequence = pointer->sequence;
    pointer_x = pointer->x;
    pointer_y = pointer->y;
    motion_remainder_x = 0;
    motion_remainder_y = 0;
  }
  bool input_t::move_to_locked(console_input_t &device, double x, double y) {
    const auto width = device.width();
    const auto height = device.height();
    if (width == 0 || height == 0) {
      return false;
    }
    x = std::clamp(x, 0.0, width - 1.0);
    y = std::clamp(y, 0.0, height - 1.0);
    if (device.is_absolute()) {
      device.set_abs_position((std::uint32_t) x, (std::uint32_t) y);
      pointer_x = x;
      pointer_y = y;
      motion_remainder_x = 0;
      motion_remainder_y = 0;
      return true;
    }
    sync_guest_pointer_locked(device);
    if (!pointer_x || !pointer_y) {
      if (!logged_no_pointer) {
        logged_no_pointer = true;
        BOOST_LOG(debug) << "qemu: the guest mouse is relative and QEMU hasn't reported the pointer position (MouseSet) yet; dropping absolute moves"sv;
      }
      return false;
    }
    // carry fractions of a pixel over, so small steps on a scaled stream still add up
    motion_remainder_x += x - *pointer_x;
    motion_remainder_y += y - *pointer_y;
    const auto dx = (std::int32_t) std::trunc(motion_remainder_x);
    const auto dy = (std::int32_t) std::trunc(motion_remainder_y);
    motion_remainder_x -= dx;
    motion_remainder_y -= dy;
    pointer_x = x;
    pointer_y = y;
    if (dx != 0 || dy != 0) {
      device.rel_motion(dx, dy);
      last_relative_motion = std::chrono::steady_clock::now();
    }
    return true;
  }
  void input_t::button_locked(console_input_t &device, mouse_button_e button, bool pressed) {
    if (pressed) {
      pressed_buttons.insert(button);
      device.button(button, true);
    } else if (pressed_buttons.erase(button) > 0) {
      device.button(button, false);
    }
  }
  void input_t::move_mouse(int delta_x, int delta_y) {
    std::lock_guard lock {mutex};
    const auto device = device_locked();
    if (!device || (delta_x == 0 && delta_y == 0)) {
      return;
    }
    sync_guest_pointer_locked(*device);
    if (device->is_absolute()) {
      if (!pointer_x || !pointer_y) {
        // nothing known about the pointer yet: start from the middle of the screen
        pointer_x = device->width() / 2.0;
        pointer_y = device->height() / 2.0;
      }
      move_to_locked(*device, *pointer_x + delta_x, *pointer_y + delta_y);
      return;
    }
    device->rel_motion(delta_x, delta_y);
    last_relative_motion = std::chrono::steady_clock::now();
    if (pointer_x && pointer_y && device->width() > 0 && device->height() > 0) {
      pointer_x = std::clamp(*pointer_x + delta_x, 0.0, device->width() - 1.0);
      pointer_y = std::clamp(*pointer_y + delta_y, 0.0, device->height() - 1.0);
    }
  }
  void input_t::abs_mouse(const platf::touch_port_t &touch_port, float x, float y) {
    std::lock_guard lock {mutex};
    const auto device = device_locked();
    if (!device || touch_port.width <= 0 || touch_port.height <= 0) {
      return;
    }
    // Moonlight's coordinates cover the captured display; scale them to the console's current size
    const double console_x = (x - touch_port.offset_x) * device->width() / touch_port.width;
    const double console_y = (y - touch_port.offset_y) * device->height() / touch_port.height;
    move_to_locked(*device, console_x, console_y);
  }
  void input_t::button_mouse(int button, bool release) {
    std::lock_guard lock {mutex};
    const auto device = device_locked();
    if (!device) {
      return;
    }
    const auto converted = qemu_button(button);
    if (!converted) {
      BOOST_LOG(debug) << "qemu: ignoring unknown mouse button "sv << button;
      return;
    }
    button_locked(*device, *converted, !release);
  }
  void input_t::scroll(int high_res_distance) {
    std::lock_guard lock {mutex};
    const auto device = device_locked();
    if (!device) {
      return;
    }
    scroll_remainder += high_res_distance;
    while (scroll_remainder >= wheel_delta) {
      scroll_remainder -= wheel_delta;
      device->button(mouse_button_e::wheel_up, true);
      device->button(mouse_button_e::wheel_up, false);
    }
    while (scroll_remainder <= -wheel_delta) {
      scroll_remainder += wheel_delta;
      device->button(mouse_button_e::wheel_down, true);
      device->button(mouse_button_e::wheel_down, false);
    }
  }
  void input_t::hscroll(int high_res_distance) {
    std::lock_guard lock {mutex};
    if (!logged_hscroll && high_res_distance != 0) {
      logged_hscroll = true;
      BOOST_LOG(info) << "qemu: horizontal scrolling isn't supported: QEMU's D-Bus mouse has no horizontal wheel buttons"sv;
    }
  }
  void input_t::keyboard_update(std::uint16_t modcode, bool release, std::uint8_t flags) {
    std::lock_guard lock {mutex};
    const auto device = device_locked();
    if (!device) {
      return;
    }
    // Moonlight has no extended-key bit, and SS_KBE_FLAG_NON_NORMALIZED doesn't change the physical key
    const std::uint16_t vk = modcode & 0xFF;
    const auto qnum = keymap::vk_to_qnum(vk);
    if (!qnum) {
      if (!logged_keys.test(vk)) {
        logged_keys.set(vk);
        BOOST_LOG(info) << "qemu: no QEMU key for virtual-key code 0x"sv << std::hex << vk << std::dec << "; ignoring it"sv;
      }
      return;
    }
    if (!release) {
      // several virtual keys can hold one key (VK_SHIFT and VK_LSHIFT); a repeated press is key repeat
      pressed_keys[*qnum].insert(vk);
      device->key(*qnum, true);
      return;
    }
    const auto held = pressed_keys.find(*qnum);
    if (held == pressed_keys.end()) {
      return;
    }
    held->second.erase(vk);
    if (held->second.empty()) {
      pressed_keys.erase(held);
      device->key(*qnum, false);
    }
  }
  void input_t::unicode(std::string_view text) {
    std::lock_guard lock {mutex};
    if (!logged_unicode && !text.empty()) {
      logged_unicode = true;
      BOOST_LOG(info) << "qemu: text input isn't supported: QEMU's D-Bus keyboard only takes key numbers"sv;
    }
  }
  void input_t::emulate_mouse_locked(console_input_t &device, std::uint32_t pointer_id, std::uint8_t event_type, double x, double y) {
    const bool is_active = mouse_contact == pointer_id;
    switch (event_type) {
      case LI_TOUCH_EVENT_DOWN:
        if (mouse_contact && !is_active) {
          return;
        }
        move_to_locked(device, x, y);
        if (!mouse_contact) {
          mouse_contact = pointer_id;
          button_locked(device, mouse_button_e::left, true);
        }
        return;
      case LI_TOUCH_EVENT_MOVE:
        if (is_active) {
          move_to_locked(device, x, y);
        }
        return;
      case LI_TOUCH_EVENT_HOVER:
        if (!mouse_contact) {
          move_to_locked(device, x, y);
        }
        return;
      case LI_TOUCH_EVENT_UP:
        if (is_active) {
          move_to_locked(device, x, y);
          button_locked(device, mouse_button_e::left, false);
          mouse_contact.reset();
        }
        return;
      case LI_TOUCH_EVENT_CANCEL:
      case LI_TOUCH_EVENT_HOVER_LEAVE:
        if (is_active) {
          button_locked(device, mouse_button_e::left, false);
          mouse_contact.reset();
        }
        return;
      case LI_TOUCH_EVENT_CANCEL_ALL:
        if (mouse_contact) {
          button_locked(device, mouse_button_e::left, false);
          mouse_contact.reset();
        }
        return;
      default:
        return;
    }
  }
  void input_t::touch_update(const platf::touch_port_t &touch_port, const platf::touch_input_t &touch) {
    std::lock_guard lock {mutex};
    const auto device = device_locked();
    if (!device) {
      return;
    }
    // Sunshine normalizes touch coordinates to the captured display
    const double x = std::clamp(touch.x, 0.0f, 1.0f) * (double) device->width();
    const double y = std::clamp(touch.y, 0.0f, 1.0f) * (double) device->height();
    if (!device->has_multitouch() || device->max_slots() <= 0) {
      emulate_mouse_locked(*device, touch.pointerId, touch.eventType, x, y);
      return;
    }
    if (!logged_touch) {
      logged_touch = true;
      BOOST_LOG(info) << "qemu: sending touch to QEMU's MultiTouch interface; the VM needs -device virtio-multitouch-pci, otherwise set native_pen_touch = disabled"sv;
    }
    const auto contact = touch_contacts.find(touch.pointerId);
    switch (touch.eventType) {
      case LI_TOUCH_EVENT_DOWN:
      case LI_TOUCH_EVENT_MOVE:
        {
          if (contact != touch_contacts.end()) {
            contact->second.x = x;
            contact->second.y = y;
            device->touch(touch_kind_e::update, contact->second.slot, x, y);
            return;
          }
          std::uint64_t slot = 0;
          const auto slot_taken = [&](std::uint64_t candidate) {
            return std::ranges::any_of(touch_contacts, [&](const auto &entry) {
              return entry.second.slot == candidate;
            });
          };
          while (slot < (std::uint64_t) device->max_slots() && slot_taken(slot)) {
            slot += 1;
          }
          if (slot >= (std::uint64_t) device->max_slots()) {
            BOOST_LOG(debug) << "qemu: all "sv << device->max_slots() << " touch slots are in use; dropping contact "sv << touch.pointerId;
            return;
          }
          touch_contacts[touch.pointerId] = {slot, x, y};
          device->touch(touch_kind_e::begin, slot, x, y);
          return;
        }
      case LI_TOUCH_EVENT_UP:
        if (contact != touch_contacts.end()) {
          device->touch(touch_kind_e::end, contact->second.slot, x, y);
          touch_contacts.erase(contact);
        }
        return;
      case LI_TOUCH_EVENT_CANCEL:
        if (contact != touch_contacts.end()) {
          // only the pointer id of a cancel is valid; use the last position
          device->touch(touch_kind_e::cancel, contact->second.slot, contact->second.x, contact->second.y);
          touch_contacts.erase(contact);
        }
        return;
      case LI_TOUCH_EVENT_CANCEL_ALL:
        for (const auto &[id, active] : touch_contacts) {
          device->touch(touch_kind_e::cancel, active.slot, active.x, active.y);
        }
        touch_contacts.clear();
        return;
      default:
        // hovering and button-only events have no contact
        return;
    }
  }
  void input_t::pen_update(const platf::touch_port_t &touch_port, const platf::pen_input_t &pen) {
    std::lock_guard lock {mutex};
    const auto device = device_locked();
    if (!device) {
      return;
    }
    const double x = std::clamp(pen.x, 0.0f, 1.0f) * (double) device->width();
    const double y = std::clamp(pen.y, 0.0f, 1.0f) * (double) device->height();
    emulate_mouse_locked(*device, pen_contact, pen.eventType, x, y);
  }
}  // namespace qemu

@@ -1,0 +1,322 @@
/**
 * @file src/platform/linux/qemu/input.h
 * @brief Declarations for sending Moonlight keyboard, mouse and touch input to a QEMU VM (`capture = qemu`).
 * @details `input_t` receives the events Sunshine's platform input functions get and turns them
 * into calls on QEMU's `org.qemu.Display1.Keyboard`, `Mouse` and `MultiTouch` interfaces of the
 * console that is being captured. Gamepads are not handled here; they stay on libvirtualhid.
 */
#pragma once
// standard includes
#include <bitset>
#include <chrono>
#include <condition_variable>
#include <cstdint>
#include <map>
#include <memory>
#include <mutex>
#include <optional>
#include <set>
#include <string>
#include <string_view>
#include <thread>
#include <utility>
#include <vector>
// local includes
#include "frame_store.h"
#include "session.h"
#include "src/platform/common.h"
namespace qemu {
  /**
   * @brief Record which session and console the capture streams, so input follows it.
   * @details Called by the capture backend whenever it registers on a console. The input sends to
   * the same console and uses the store's `MouseSet` position to convert absolute input for a
   * relative guest mouse. Only weak references are kept.
   *
   * @param session Session the capture uses.
   * @param console_id Captured console.
   * @param store Frame store registered on the console.
   */
  void set_capture_console(const std::shared_ptr<session_t> &session, std::uint32_t console_id, const std::shared_ptr<frame_store_t> &store);
  /**
   * @brief Release every key, button and touch that the live QEMU inputs hold.
   * @details Called when streaming stops, so nothing stays pressed in the guest after the last
   * client disconnected.
   */
  void release_all_inputs();
  /**
   * @brief Count the live QEMU inputs.
   *
   * @return Number of `input_t` objects.
   */
  std::size_t input_count();
  /**
   * @brief Moonlight keyboard, mouse and touch input for one QEMU VM.
   * @details Nothing here blocks the caller on QEMU: connecting happens on a background thread
   * (events that arrive before it finished are dropped), and every D-Bus call is asynchronous and
   * ordered. All methods are thread-safe.
   *
   * - Keys: Windows virtual-key codes are translated to QEMU key numbers (`keymap.h`); keys with
   *   no QEMU number are logged once and ignored.
   * - Mouse: follows `Mouse.IsAbsolute`. Absolute input for an absolute guest is scaled to console
   *   pixels; relative input for a relative guest is passed on. Relative input for an absolute
   *   guest moves a tracked pointer position. Absolute input for a relative guest becomes relative
   *   motion from the guest pointer position QEMU reported with `MouseSet`, and is dropped until
   *   there is one.
   * - Scroll: every 120 units are one wheel step; the remainder is kept. QEMU has no horizontal
   *   wheel button, so horizontal scrolling is ignored.
   * - Touch: contacts get `MultiTouch` slots up to `MaxSlots`; without `MultiTouch` the first
   *   contact drives the mouse (position and left button). Pens drive the mouse the same way.
   *   QEMU exports `MultiTouch` whether or not the VM has a multi-touch device, so touches reach
   *   the guest only with `-device virtio-multitouch-pci`.
   */
  class input_t {
  public:
    /**
     * @brief Create the input and start connecting to QEMU in the background.
     *
     * @param address D-Bus address of QEMU's bus, or empty for the session bus.
     */
    explicit input_t(std::string address);
    ~input_t();
    input_t(const input_t &) = delete;
    input_t &operator=(const input_t &) = delete;
    /**
     * @brief Wait until the input is connected to a console, connecting if needed.
     *
     * @param timeout Maximum time to wait.
     * @return True when events are delivered.
     */
    bool wait_for_console(std::chrono::milliseconds timeout);
    /**
     * @brief Mouse mode of the connected console.
     *
     * @return `Mouse.IsAbsolute`, or nothing while not connected.
     */
    [[nodiscard]] std::optional<bool> guest_absolute();
    /**
     * @brief Size of the connected console.
     *
     * @return Width and height in pixels, or nothing while not connected.
     */
    [[nodiscard]] std::optional<std::pair<std::uint32_t, std::uint32_t>> console_size();
    /**
     * @brief Wait until QEMU answered every input call sent so far.
     *
     * @param timeout Maximum time to wait.
     * @return True when nothing is pending (also when not connected).
     */
    bool flush(std::chrono::milliseconds timeout);
    /**
     * @brief Move the mouse by a relative amount.
     *
     * @param delta_x Horizontal motion in client pixels.
     * @param delta_y Vertical motion in client pixels.
     */
    void move_mouse(int delta_x, int delta_y);
    /**
     * @brief Move the mouse to an absolute position.
     *
     * @param touch_port Area the coordinates refer to (the captured display).
     * @param x X position within the touch port.
     * @param y Y position within the touch port.
     */
    void abs_mouse(const platf::touch_port_t &touch_port, float x, float y);
    /**
     * @brief Press or release a mouse button.
     *
     * @param button Moonlight button: 1 left, 2 middle, 3 right, 4 side (X1), 5 extra (X2).
     * @param release True for a release.
     */
    void button_mouse(int button, bool release);
    /**
     * @brief Scroll vertically.
     *
     * @param high_res_distance Distance in 1/120 wheel steps; positive scrolls up.
     */
    void scroll(int high_res_distance);
    /**
     * @brief Scroll horizontally; QEMU's D-Bus mouse has no horizontal wheel, so this only logs once.
     *
     * @param high_res_distance Distance in 1/120 wheel steps.
     */
    void hscroll(int high_res_distance);
    /**
     * @brief Press or release a key.
     *
     * @param modcode Windows virtual-key code in the low byte.
     * @param release True for a release.
     * @param flags Moonlight keyboard flags (`SS_KBE_FLAG_*`); none changes the key on this path.
     */
    void keyboard_update(std::uint16_t modcode, bool release, std::uint8_t flags);
    /**
     * @brief Type text; QEMU's D-Bus keyboard only takes key numbers, so this only logs once.
     *
     * @param text UTF-8 text.
     */
    void unicode(std::string_view text);
    /**
     * @brief Handle a touch event.
     *
     * @param touch_port Area the coordinates refer to.
     * @param touch Touch event with coordinates normalized to 0..1.
     */
    void touch_update(const platf::touch_port_t &touch_port, const platf::touch_input_t &touch);
    /**
     * @brief Handle a pen event by moving the mouse and pressing the left button while touching.
     *
     * @param touch_port Area the coordinates refer to.
     * @param pen Pen event with coordinates normalized to 0..1.
     */
    void pen_update(const platf::touch_port_t &touch_port, const platf::pen_input_t &pen);
    /**
     * @brief Release every key, button and touch contact this input holds in the guest.
     */
    void release_all();
  private:
    /**
     * @brief A console connection with the capture binding it was made for.
     */
    struct target_t {
      std::shared_ptr<console_input_t> device;  ///< Console input.
      std::weak_ptr<session_t> session;  ///< Session of the device.
      std::uint64_t binding {0};  ///< Capture binding generation the target was chosen from.
    };
    /**
     * @brief A touch contact holding a `MultiTouch` slot.
     */
    struct touch_contact_t {
      std::uint64_t slot {0};  ///< Slot number.
      double x {0};  ///< Last X position in console pixels.
      double y {0};  ///< Last Y position in console pixels.
    };
    /**
     * @brief Get the console to send to, asking the worker to (re)connect when needed.
     * @details Caller holds `mutex`.
     *
     * @return Console input, or nullptr while not connected (the event is dropped).
     */
    console_input_t *device_locked();
    /**
     * @brief Connect to the captured console, or the configured one; runs on the worker thread.
     *
     * @return New target, or nothing on failure.
     */
    std::optional<target_t> connect();
    /**
     * @brief Worker thread: connects whenever asked to.
     */
    void run();
    /**
     * @brief Forget all pressed state without sending releases (the guest is gone or changed).
     * @details Caller holds `mutex`.
     */
    void forget_state_locked();
    /**
     * @brief Release everything held on a device.
     * @details Caller holds `mutex`.
     *
     * @param device Device to send the releases to.
     */
    void release_all_locked(console_input_t &device);
    /**
     * @brief Take the guest pointer position from QEMU's latest `MouseSet`, when it is newer.
     * @details Only reports of a visible cursor count. Reports that arrive while our own relative
     * motion is still on its way describe an older position, so they are only taken after a pause
     * in motion. Caller holds `mutex`.
     *
     * @param device Target device.
     */
    void sync_guest_pointer_locked(const console_input_t &device);
    /**
     * @brief Move the guest pointer to a position in console pixels, converting for a relative mouse.
     * @details Caller holds `mutex`.
     *
     * @param device Target device.
     * @param x X position in console pixels.
     * @param y Y position in console pixels.
     * @return False when a relative guest's pointer position is unknown and the move was dropped.
     */
    bool move_to_locked(console_input_t &device, double x, double y);
    /**
     * @brief Press or release a button, tracking it for `release_all()`.
     * @details Caller holds `mutex`.
     *
     * @param device Target device.
     * @param button Button.
     * @param pressed True for a press.
     */
    void button_locked(console_input_t &device, mouse_button_e button, bool pressed);
    /**
     * @brief Drive the mouse from a single touch or pen contact.
     * @details Caller holds `mutex`.
     *
     * @param device Target device.
     * @param pointer_id Contact id; only the first active contact moves the mouse.
     * @param event_type Moonlight touch event type.
     * @param x X position in console pixels.
     * @param y Y position in console pixels.
     */
    void emulate_mouse_locked(console_input_t &device, std::uint32_t pointer_id, std::uint8_t event_type, double x, double y);
    std::string address;  ///< D-Bus address of QEMU's bus.
    std::mutex mutex;  ///< Guards everything below.
    std::condition_variable wake;  ///< Wakes the worker or `wait_for_console()`.
    std::thread worker;  ///< Connects in the background.
    bool stopping {false};  ///< Whether the worker should exit.
    bool connect_requested {true};  ///< Whether the worker should (re)connect.
    bool connecting {false};  ///< Whether the worker is connecting right now.
    std::chrono::steady_clock::time_point next_attempt;  ///< Earliest time for the next connection attempt.
    std::optional<target_t> target;  ///< Current console connection.
    std::chrono::steady_clock::time_point last_drop_log;  ///< When a dropped event was last logged.
    std::map<std::uint32_t, std::set<std::uint16_t>> pressed_keys;  ///< Pressed QEMU key numbers and the virtual keys holding each.
    std::set<mouse_button_e> pressed_buttons;  ///< Pressed mouse buttons.
    int scroll_remainder {0};  ///< Scroll distance not yet sent, in 1/120 steps.
    std::optional<double> pointer_x;  ///< Where the guest pointer is believed to be, in console pixels.
    std::optional<double> pointer_y;  ///< Where the guest pointer is believed to be, in console pixels.
    double motion_remainder_x {0};  ///< Relative motion below one pixel not yet sent.
    double motion_remainder_y {0};  ///< Relative motion below one pixel not yet sent.
    std::uint64_t pointer_sequence {0};  ///< `MouseSet` report last taken as the pointer position.
    std::chrono::steady_clock::time_point last_relative_motion;  ///< When relative motion was last sent.
    std::map<std::uint32_t, touch_contact_t> touch_contacts;  ///< Active touch contacts by Moonlight pointer id.
    std::optional<std::uint32_t> mouse_contact;  ///< Contact that drives the mouse when there is no multi-touch.
    std::bitset<256> logged_keys;  ///< Virtual keys already logged as unmapped.
    bool logged_hscroll {false};  ///< Whether horizontal scrolling was logged as unsupported.
    bool logged_unicode {false};  ///< Whether text input was logged as unsupported.
    bool logged_no_pointer {false};  ///< Whether a dropped absolute move for a relative guest was logged.
    bool logged_touch {false};  ///< Whether the multi-touch device hint was logged.
  };
}  // namespace qemu

@@ -1,0 +1,227 @@
/**
 * @file src/platform/linux/qemu/keymap.cpp
 * @brief Definitions for translating Moonlight key codes to QEMU key numbers.
 */
// class header include
#include "keymap.h"
// standard includes
#include <array>
#include <utility>
#include <vector>
// platform includes
#include <linux/input-event-codes.h>
// Generated by keycodemapdb's keymap-gen, see third-party/qemu-keycodemapdb/README.md.
extern const std::vector<unsigned short> qemu_keycodemapdb_linux_to_qnum;  ///< Linux key code -> QEMU key number, 0 for none.
extern const std::vector<unsigned short> qemu_keycodemapdb_qnum_to_linux;  ///< QEMU key number -> Linux key code, 0 for none.
namespace qemu::keymap {
  namespace {
    /**
     * @brief Windows virtual-key codes and the Linux keys they stand for.
     * @details The first block is the table Sunshine's Linux input backend uses: libvirtualhid's
     * `key_code_to_linux` (`third-party/libvirtualhid/src/platform/linux/uhid_backend.cpp` at
     * `6fdb8bd4`, MIT), including its ranges for digits, letters, keypad digits and F1-F24. The
     * second block adds the keys that table has no entry for, taken from keycodemapdb's `Win32`
     * column (`third-party/qemu-keycodemapdb`), so a guest also gets Pause, Menu, media, browser
     * and IME keys.
     */
    constexpr auto vk_pairs = std::to_array<std::pair<std::uint8_t, int>>({
      // libvirtualhid key_code_to_linux: special keys
      {0x08, KEY_BACKSPACE},
      {0x09, KEY_TAB},
      {0x0D, KEY_ENTER},
      {0x10, KEY_LEFTSHIFT},
      {0xA0, KEY_LEFTSHIFT},
      {0x11, KEY_LEFTCTRL},
      {0xA2, KEY_LEFTCTRL},
      {0x12, KEY_LEFTALT},
      {0xA4, KEY_LEFTALT},
      {0x14, KEY_CAPSLOCK},
      {0x1B, KEY_ESC},
      {0x20, KEY_SPACE},
      {0x21, KEY_PAGEUP},
      {0x22, KEY_PAGEDOWN},
      {0x23, KEY_END},
      {0x24, KEY_HOME},
      {0x25, KEY_LEFT},
      {0x26, KEY_UP},
      {0x27, KEY_RIGHT},
      {0x28, KEY_DOWN},
      {0x2C, KEY_SYSRQ},
      {0x2D, KEY_INSERT},
      {0x2E, KEY_DELETE},
      {0x5B, KEY_LEFTMETA},
      {0x5C, KEY_RIGHTMETA},
      {0x6A, KEY_KPASTERISK},
      {0x6B, KEY_KPPLUS},
      {0x6D, KEY_KPMINUS},
      {0x6E, KEY_KPDOT},
      {0x6F, KEY_KPSLASH},
      {0x90, KEY_NUMLOCK},
      {0x91, KEY_SCROLLLOCK},
      {0xA1, KEY_RIGHTSHIFT},
      {0xA3, KEY_RIGHTCTRL},
      {0xA5, KEY_RIGHTALT},
      {0xBA, KEY_SEMICOLON},
      {0xBB, KEY_EQUAL},
      {0xBC, KEY_COMMA},
      {0xBD, KEY_MINUS},
      {0xBE, KEY_DOT},
      {0xBF, KEY_SLASH},
      {0xC0, KEY_GRAVE},
      {0xDB, KEY_LEFTBRACE},
      {0xDC, KEY_BACKSLASH},
      {0xDD, KEY_RIGHTBRACE},
      {0xDE, KEY_APOSTROPHE},
      {0xE2, KEY_102ND},
      // libvirtualhid key_code_to_linux: digits 0x30-0x39
      {0x30, KEY_0},
      {0x31, KEY_1},
      {0x32, KEY_2},
      {0x33, KEY_3},
      {0x34, KEY_4},
      {0x35, KEY_5},
      {0x36, KEY_6},
      {0x37, KEY_7},
      {0x38, KEY_8},
      {0x39, KEY_9},
      // libvirtualhid key_code_to_linux: letters 0x41-0x5A
      {0x41, KEY_A},
      {0x42, KEY_B},
      {0x43, KEY_C},
      {0x44, KEY_D},
      {0x45, KEY_E},
      {0x46, KEY_F},
      {0x47, KEY_G},
      {0x48, KEY_H},
      {0x49, KEY_I},
      {0x4A, KEY_J},
      {0x4B, KEY_K},
      {0x4C, KEY_L},
      {0x4D, KEY_M},
      {0x4E, KEY_N},
      {0x4F, KEY_O},
      {0x50, KEY_P},
      {0x51, KEY_Q},
      {0x52, KEY_R},
      {0x53, KEY_S},
      {0x54, KEY_T},
      {0x55, KEY_U},
      {0x56, KEY_V},
      {0x57, KEY_W},
      {0x58, KEY_X},
      {0x59, KEY_Y},
      {0x5A, KEY_Z},
      // libvirtualhid key_code_to_linux: keypad digits 0x60-0x69
      {0x60, KEY_KP0},
      {0x61, KEY_KP1},
      {0x62, KEY_KP2},
      {0x63, KEY_KP3},
      {0x64, KEY_KP4},
      {0x65, KEY_KP5},
      {0x66, KEY_KP6},
      {0x67, KEY_KP7},
      {0x68, KEY_KP8},
      {0x69, KEY_KP9},
      // libvirtualhid key_code_to_linux: F1-F24 0x70-0x87
      {0x70, KEY_F1},
      {0x71, KEY_F2},
      {0x72, KEY_F3},
      {0x73, KEY_F4},
      {0x74, KEY_F5},
      {0x75, KEY_F6},
      {0x76, KEY_F7},
      {0x77, KEY_F8},
      {0x78, KEY_F9},
      {0x79, KEY_F10},
      {0x7A, KEY_F11},
      {0x7B, KEY_F12},
      {0x7C, KEY_F13},
      {0x7D, KEY_F14},
      {0x7E, KEY_F15},
      {0x7F, KEY_F16},
      {0x80, KEY_F17},
      {0x81, KEY_F18},
      {0x82, KEY_F19},
      {0x83, KEY_F20},
      {0x84, KEY_F21},
      {0x85, KEY_F22},
      {0x86, KEY_F23},
      {0x87, KEY_F24},
      // keycodemapdb Win32 column: keys libvirtualhid's table doesn't map
      {0x13, KEY_PAUSE},  // VK_PAUSE
      {0x15, KEY_HANGEUL},  // VK_HANGUL (also VK_KANA)
      {0x19, KEY_HANJA},  // VK_HANJA
      {0x1C, KEY_HENKAN},  // VK_CONVERT
      {0x1D, KEY_MUHENKAN},  // VK_NONCONVERT
      {0x29, KEY_SELECT},  // VK_SELECT
      {0x2A, KEY_PRINT},  // VK_PRINT
      {0x2F, KEY_HELP},  // VK_HELP
      {0x5D, KEY_COMPOSE},  // VK_APPS, the Menu key
      {0x5F, KEY_SLEEP},  // VK_SLEEP
      {0x6C, KEY_KPCOMMA},  // VK_SEPARATOR
      {0xA6, KEY_BACK},  // VK_BROWSER_BACK
      {0xA7, KEY_FORWARD},  // VK_BROWSER_FORWARD
      {0xA8, KEY_REFRESH},  // VK_BROWSER_REFRESH
      {0xA9, KEY_STOP},  // VK_BROWSER_STOP
      {0xAA, KEY_SEARCH},  // VK_BROWSER_SEARCH
      {0xAB, KEY_FAVORITES},  // VK_BROWSER_FAVORITES
      {0xAC, KEY_HOMEPAGE},  // VK_BROWSER_HOME
      {0xAD, KEY_MUTE},  // VK_VOLUME_MUTE
      {0xAE, KEY_VOLUMEDOWN},  // VK_VOLUME_DOWN
      {0xAF, KEY_VOLUMEUP},  // VK_VOLUME_UP
      {0xB0, KEY_NEXTSONG},  // VK_MEDIA_NEXT_TRACK
      {0xB1, KEY_PREVIOUSSONG},  // VK_MEDIA_PREV_TRACK
      {0xB2, KEY_STOPCD},  // VK_MEDIA_STOP
      {0xB3, KEY_PLAYPAUSE},  // VK_MEDIA_PLAY_PAUSE
      {0xB4, KEY_EMAIL},  // VK_LAUNCH_MAIL
      {0xF2, KEY_KATAKANAHIRAGANA},  // VK_OEM_COPY
      {0xFA, KEY_PLAY},  // VK_PLAY
      {0xFB, KEY_ZOOM},  // VK_ZOOM
    });
    /**
     * @brief Build the virtual-key lookup table.
     *
     * @return Linux key code for each virtual-key code, 0 (`KEY_RESERVED`) for none.
     */
    constexpr std::array<std::uint16_t, 256> make_vk_table() {
      std::array<std::uint16_t, 256> table {};
      for (const auto &[vk, key] : vk_pairs) {
        table[vk] = (std::uint16_t) key;
      }
      return table;
    }
    constexpr auto vk_table = make_vk_table();  ///< Linux key code by virtual-key code.
  }  // namespace
  std::optional<int> vk_to_linux(std::uint16_t vk) {
    if (vk >= vk_table.size() || vk_table[vk] == KEY_RESERVED) {
      return std::nullopt;
    }
    return vk_table[vk];
  }
  std::optional<std::uint32_t> linux_to_qnum(int key) {
    if (key <= KEY_RESERVED || (std::size_t) key >= qemu_keycodemapdb_linux_to_qnum.size() || qemu_keycodemapdb_linux_to_qnum[key] == 0) {
      return std::nullopt;
    }
    return qemu_keycodemapdb_linux_to_qnum[key];
  }
  std::optional<int> qnum_to_linux(std::uint32_t qnum) {
    if (qnum == 0 || qnum >= qemu_keycodemapdb_qnum_to_linux.size() || qemu_keycodemapdb_qnum_to_linux[qnum] == KEY_RESERVED) {
      return std::nullopt;
    }
    return qemu_keycodemapdb_qnum_to_linux[qnum];
  }
  std::optional<std::uint32_t> vk_to_qnum(std::uint16_t vk) {
    const auto key = vk_to_linux(vk);
    return key ? linux_to_qnum(*key) : std::nullopt;
  }
}  // namespace qemu::keymap

@@ -1,0 +1,51 @@
/**
 * @file src/platform/linux/qemu/keymap.h
 * @brief Declarations for translating Moonlight key codes to QEMU key numbers.
 * @details Moonlight sends Windows virtual-key codes. QEMU's `org.qemu.Display1.Keyboard` takes a
 * QEMU key number ("qnum": the XT scan code, with the `0xe0` prefix folded into the high bit).
 * The translation goes through Linux input key codes: virtual-key -> `KEY_*` with the table
 * Sunshine uses on Linux hosts, then `KEY_*` -> qnum with QEMU's keycodemapdb data
 * (`third-party/qemu-keycodemapdb`).
 */
#pragma once
// standard includes
#include <cstdint>
#include <optional>
namespace qemu::keymap {
  /**
   * @brief Translate a Windows virtual-key code to a Linux input key code.
   * @details Side-less modifiers map to the left key (`VK_SHIFT` -> `KEY_LEFTSHIFT`), like
   * Sunshine's Linux input backend. Moonlight doesn't send the extended-key bit, so keys that only
   * differ by it share a code: `VK_RETURN` is `KEY_ENTER` for the main and the keypad Enter.
   *
   * @param vk Virtual-key code (the low byte of Moonlight's key code).
   * @return `KEY_*` code, or nothing for codes that aren't keys or have no Linux key.
   */
  std::optional<int> vk_to_linux(std::uint16_t vk);
  /**
   * @brief Translate a Linux input key code to a QEMU key number.
   *
   * @param key `KEY_*` code.
   * @return QEMU key number, or nothing when QEMU has no number for the key.
   */
  std::optional<std::uint32_t> linux_to_qnum(int key);
  /**
   * @brief Translate a QEMU key number back to a Linux input key code, as QEMU decodes it.
   *
   * @param qnum QEMU key number.
   * @return `KEY_*` code, or nothing for numbers QEMU doesn't decode.
   */
  std::optional<int> qnum_to_linux(std::uint32_t qnum);
  /**
   * @brief Translate a Windows virtual-key code to a QEMU key number.
   *
   * @param vk Virtual-key code.
   * @return QEMU key number, or nothing when either step has no mapping.
   */
  std::optional<std::uint32_t> vk_to_qnum(std::uint16_t vk);
}  // namespace qemu::keymap

@@ -162,11 +162,11 @@
        done.get();
      }
    private:
      /**
       * @brief Queue a function on the loop without waiting.
       * @details Functions posted from one thread run in the order they were posted.
       *
       * @param fn Function to run; must outlive its execution.
       * @param fn Function to run.
       */
      void post(std::function<void()> fn) {
        auto source = g_idle_source_new();
@@ -186,6 +186,7 @@
        g_source_unref(source);
      }
    private:
      GMainContext *context;  ///< Context owned by the loop thread.
      GMainLoop *loop;  ///< Loop running on the thread.
      std::thread thread;  ///< Thread running the loop.
@@ -370,6 +371,125 @@
    };
    /**
     * @brief Calls queued on a console's input interfaces that QEMU hasn't answered yet.
     * @details Shared with the reply callbacks, which may run after the console input is gone.
     */
    struct pending_calls_t {
      std::mutex mutex;  ///< Guards `count`.
      std::condition_variable idle;  ///< Signaled when `count` drops to zero.
      int count {0};  ///< Queued or sent calls without a reply.
      std::atomic<int> errors {0};  ///< Calls QEMU answered with an error.
    };
    /**
     * @brief Keyboard, mouse and multi-touch proxies of one console, driven from the session's input thread.
     */
    class console_input_impl_t: public console_input_t {
    public:
      /**
       * @brief Create unconnected console input.
       *
       * @param session Session that owns the input thread.
       * @param console_id Console to send input to.
       * @param timeout_ms Timeout of each call.
       */
      console_input_impl_t(std::shared_ptr<session_impl_t> session, std::uint32_t console_id, int timeout_ms);
      ~console_input_impl_t() override;
      console_input_impl_t(const console_input_impl_t &) = delete;
      console_input_impl_t &operator=(const console_input_impl_t &) = delete;
      /**
       * @brief Create the proxies and read their properties.
       * @details Must run on the session's input thread, so property changes are delivered there.
       *
       * @param connection Bus connection.
       * @param cancellable Cancels the property reads when the deadline passes.
       * @return True when the console exists.
       */
      bool start(GDBusConnection *connection, GCancellable *cancellable);
      std::uint32_t console_id() const override {
        return id;
      }
      bool alive() const override;
      bool is_absolute() const override {
        return absolute;
      }
      bool has_multitouch() const override {
        return multitouch != nullptr;
      }
      int max_slots() const override {
        return slots;
      }
      std::uint32_t width() const override {
        return console_width;
      }
      std::uint32_t height() const override {
        return console_height;
      }
      void key(std::uint32_t qnum, bool pressed) override;
      void button(mouse_button_e button, bool pressed) override;
      void set_abs_position(std::uint32_t x, std::uint32_t y) override;
      void rel_motion(std::int32_t dx, std::int32_t dy) override;
      void touch(touch_kind_e kind, std::uint64_t slot, double x, double y) override;
      bool flush(std::chrono::milliseconds timeout) override;
    private:
      /**
       * @brief Queue a call to be made on the input thread, after every call queued before it.
       *
       * @param call Function that starts one asynchronous call, passing `reply_data()` to the reply callback.
       */
      void enqueue(std::function<void()> call);
      /**
       * @brief Run the queued calls in order; runs on the input thread.
       */
      void drain();
      /**
       * @brief Create the user data for one reply callback.
       *
       * @param method Method name for error logs.
       * @return Data that `on_reply` frees.
       */
      gpointer reply_data(const char *method);
      /**
       * @brief Read the cached properties into the atomics; runs on the input thread.
       */
      void read_properties();
      static void on_reply(GObject *source, GAsyncResult *result, gpointer data);
      static void on_property(GObject *object, GParamSpec *pspec, gpointer self);
      std::shared_ptr<session_impl_t> session;  ///< Keeps the session and its input thread alive.
      std::uint32_t id;  ///< Console id.
      int timeout_ms;  ///< Timeout of each call.
      std::shared_ptr<pending_calls_t> pending {std::make_shared<pending_calls_t>()};  ///< Calls without a reply.
      std::mutex queue_mutex;  ///< Guards `queue` and `drain_posted`.
      std::vector<std::function<void()>> queue;  ///< Calls not yet started, in order.
      bool drain_posted {false};  ///< Whether a drain is queued on the input thread.
      QemuDBusDisplay1Console *console {nullptr};  ///< Console proxy, for Width and Height.
      QemuDBusDisplay1Keyboard *keyboard {nullptr};  ///< Keyboard proxy, when the console has one.
      QemuDBusDisplay1Mouse *mouse {nullptr};  ///< Mouse proxy, when the console has one.
      QemuDBusDisplay1MultiTouch *multitouch {nullptr};  ///< MultiTouch proxy, when the console has one.
      std::atomic<bool> absolute {false};  ///< Cached `Mouse.IsAbsolute`.
      std::atomic<int> slots {0};  ///< Cached `MultiTouch.MaxSlots`.
      std::atomic<std::uint32_t> console_width {0};  ///< Cached `Console.Width`.
      std::atomic<std::uint32_t> console_height {0};  ///< Cached `Console.Height`.
    };
    /**
     * @brief GDBus implementation of the session.
     */
    class session_impl_t: public session_t, public std::enable_shared_from_this<session_impl_t> {
@@ -479,6 +599,42 @@
        return registration;
      }
      std::shared_ptr<console_input_t> open_input(std::uint32_t console_id) override {
        const bool known = std::ranges::any_of(console_proxies, [&](const auto &entry) {
          return entry.first == console_id;
        });
        if (!known || !is_alive) {
          BOOST_LOG(error) << "qemu: console "sv << console_id << " is not available for input"sv;
          return nullptr;
        }
        auto input = std::make_shared<console_input_impl_t>(shared_from_this(), console_id, timeout_ms);
        bool ok = false;
        deadline_t deadline {timeout};
        input_loop().invoke([&]() {
          ok = input->start(connection, deadline.cancellable);
        });
        if (!ok) {
          return nullptr;
        }
        return input;
      }
      /**
       * @brief Thread that sends input to QEMU, created on first use.
       * @details It only makes asynchronous calls, so input never waits behind a blocking
       * registration on the bus thread or behind display updates on the listener thread.
       *
       * @return The input thread.
       */
      loop_thread_t &input_loop() {
        std::lock_guard lock {input_loop_mutex};
        if (!input_loop_thread) {
          input_loop_thread = std::make_unique<loop_thread_t>();
        }
        return *input_loop_thread;
      }
      /**
       * @brief Thread that owns the bus connection and makes blocking calls to QEMU.
       */
@@ -706,7 +862,211 @@
      QemuDBusDisplay1VM *vm_proxy {nullptr};  ///< VM proxy.
      QemuDBusDisplay1Audio *audio_proxy {nullptr};  ///< Audio proxy, created on the first audio registration.
      std::vector<std::pair<std::uint32_t, QemuDBusDisplay1Console *>> console_proxies;  ///< Console proxies in ConsoleIDs order.
      std::mutex input_loop_mutex;  ///< Guards `input_loop_thread`.
      std::unique_ptr<loop_thread_t> input_loop_thread;  ///< Input thread, created by the first `open_input()`.
    };
    console_input_impl_t::console_input_impl_t(std::shared_ptr<session_impl_t> session, std::uint32_t console_id, int timeout_ms):
        session {std::move(session)},
        id {console_id},
        timeout_ms {timeout_ms} {
    }
    console_input_impl_t::~console_input_impl_t() {
      // let queued calls go out and be answered, so no reply arrives after the proxies are gone
      if (!flush(std::chrono::milliseconds {timeout_ms})) {
        BOOST_LOG(warning) << "qemu: input calls to console "sv << id << " still pending at teardown"sv;
      }
      session->input_loop().invoke([this]() {
        for (auto object : {(GObject *) console, (GObject *) keyboard, (GObject *) mouse, (GObject *) multitouch}) {
          if (object) {
            g_signal_handlers_disconnect_by_data(object, this);
            g_object_unref(object);
          }
        }
        console = nullptr;
        keyboard = nullptr;
        mouse = nullptr;
        multitouch = nullptr;
      });
    }
    bool console_input_impl_t::start(GDBusConnection *connection, GCancellable *cancellable) {
      GError *err = nullptr;
      const auto path = "/org/qemu/Display1/Console_" + std::to_string(id);
      const auto flags = G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START;
      console = qemu_dbus_display1_console_proxy_new_sync(connection, flags, bus_name, path.c_str(), cancellable, &err);
      if (!console) {
        BOOST_LOG(error) << "qemu: couldn't create the console "sv << id << " proxy for input: "sv << err->message;
        g_clear_error(&err);
        return false;
      }
      const auto interfaces = to_strings(qemu_dbus_display1_console_get_interfaces(console));
      const auto has = [&](std::string_view name) {
        return std::ranges::find(interfaces, name) != interfaces.end();
      };
      if (has("org.qemu.Display1.Keyboard")) {
        keyboard = qemu_dbus_display1_keyboard_proxy_new_sync(connection, flags, bus_name, path.c_str(), cancellable, &err);
      }
      if (!err && has("org.qemu.Display1.Mouse")) {
        mouse = qemu_dbus_display1_mouse_proxy_new_sync(connection, flags, bus_name, path.c_str(), cancellable, &err);
      }
      if (!err && has("org.qemu.Display1.MultiTouch")) {
        multitouch = qemu_dbus_display1_multi_touch_proxy_new_sync(connection, flags, bus_name, path.c_str(), cancellable, &err);
      }
      if (err) {
        BOOST_LOG(error) << "qemu: couldn't create the input proxies of console "sv << id << ": "sv << err->message;
        g_clear_error(&err);
        return false;
      }
      g_signal_connect(console, "notify::width", G_CALLBACK(&console_input_impl_t::on_property), this);
      g_signal_connect(console, "notify::height", G_CALLBACK(&console_input_impl_t::on_property), this);
      if (mouse) {
        g_signal_connect(mouse, "notify::is-absolute", G_CALLBACK(&console_input_impl_t::on_property), this);
      }
      if (multitouch) {
        g_signal_connect(multitouch, "notify::max-slots", G_CALLBACK(&console_input_impl_t::on_property), this);
      }
      read_properties();
      BOOST_LOG(info) << "qemu: sending input to console "sv << id << " (keyboard: "sv << (keyboard ? "yes"sv : "no"sv) << ", mouse: "sv << (mouse ? (absolute ? "absolute"sv : "relative"sv) : "no"sv) << ", touch slots: "sv << slots << ')';
      return true;
    }
    bool console_input_impl_t::alive() const {
      return session->alive();
    }
    void console_input_impl_t::read_properties() {
      console_width = qemu_dbus_display1_console_get_width(console);
      console_height = qemu_dbus_display1_console_get_height(console);
      const bool was_absolute = absolute;
      absolute = mouse && qemu_dbus_display1_mouse_get_is_absolute(mouse);
      slots = multitouch ? std::max(0, qemu_dbus_display1_multi_touch_get_max_slots(multitouch)) : 0;
      if (was_absolute != absolute) {
        BOOST_LOG(debug) << "qemu: console "sv << id << " mouse is now "sv << (absolute ? "absolute"sv : "relative"sv);
      }
    }
    void console_input_impl_t::on_property(GObject *object, GParamSpec *pspec, gpointer self) {
      ((console_input_impl_t *) self)->read_properties();
    }
    void console_input_impl_t::enqueue(std::function<void()> call) {
      {
        std::lock_guard lock {pending->mutex};
        pending->count += 1;
      }
      std::lock_guard lock {queue_mutex};
      queue.emplace_back(std::move(call));
      if (!drain_posted) {
        drain_posted = true;
        // the session (and so the input thread) outlives this object: the destructor flushes first
        session->input_loop().post([this]() {
          drain();
        });
      }
    }
    void console_input_impl_t::drain() {
      std::vector<std::function<void()>> calls;
      {
        std::lock_guard lock {queue_mutex};
        calls.swap(queue);
        drain_posted = false;
      }
      for (auto &call : calls) {
        call();
      }
    }
    gpointer console_input_impl_t::reply_data(const char *method) {
      return new std::pair<std::shared_ptr<pending_calls_t>, const char *> {pending, method};
    }
    void console_input_impl_t::on_reply(GObject *source, GAsyncResult *result, gpointer data) {
      std::unique_ptr<std::pair<std::shared_ptr<pending_calls_t>, const char *>> call {(std::pair<std::shared_ptr<pending_calls_t>, const char *> *) data};
      auto &state = *call->first;
      GError *err = nullptr;
      if (auto reply = g_dbus_proxy_call_finish(G_DBUS_PROXY(source), result, &err)) {
        g_variant_unref(reply);
      } else {
        // the first errors are worth a warning; a guest switching IsAbsolute can fail a few moves
        const auto count = ++state.errors;
        BOOST_LOG(count <= 3 ? warning : debug) << "qemu: "sv << call->second << " failed: "sv << err->message;
        g_clear_error(&err);
      }
      std::lock_guard lock {state.mutex};
      state.count -= 1;
      if (state.count == 0) {
        state.idle.notify_all();
      }
    }
    void console_input_impl_t::key(std::uint32_t qnum, bool pressed) {
      if (!keyboard) {
        return;
      }
      enqueue([this, qnum, pressed]() {
        if (pressed) {
          qemu_dbus_display1_keyboard_call_press(keyboard, qnum, G_DBUS_CALL_FLAGS_NONE, timeout_ms, nullptr, &console_input_impl_t::on_reply, reply_data("Keyboard.Press"));
        } else {
          qemu_dbus_display1_keyboard_call_release(keyboard, qnum, G_DBUS_CALL_FLAGS_NONE, timeout_ms, nullptr, &console_input_impl_t::on_reply, reply_data("Keyboard.Release"));
        }
      });
    }
    void console_input_impl_t::button(mouse_button_e button, bool pressed) {
      if (!mouse) {
        return;
      }
      enqueue([this, button, pressed]() {
        if (pressed) {
          qemu_dbus_display1_mouse_call_press(mouse, (guint) button, G_DBUS_CALL_FLAGS_NONE, timeout_ms, nullptr, &console_input_impl_t::on_reply, reply_data("Mouse.Press"));
        } else {
          qemu_dbus_display1_mouse_call_release(mouse, (guint) button, G_DBUS_CALL_FLAGS_NONE, timeout_ms, nullptr, &console_input_impl_t::on_reply, reply_data("Mouse.Release"));
        }
      });
    }
    void console_input_impl_t::set_abs_position(std::uint32_t x, std::uint32_t y) {
      if (!mouse) {
        return;
      }
      enqueue([this, x, y]() {
        qemu_dbus_display1_mouse_call_set_abs_position(mouse, x, y, G_DBUS_CALL_FLAGS_NONE, timeout_ms, nullptr, &console_input_impl_t::on_reply, reply_data("Mouse.SetAbsPosition"));
      });
    }
    void console_input_impl_t::rel_motion(std::int32_t dx, std::int32_t dy) {
      if (!mouse) {
        return;
      }
      enqueue([this, dx, dy]() {
        qemu_dbus_display1_mouse_call_rel_motion(mouse, dx, dy, G_DBUS_CALL_FLAGS_NONE, timeout_ms, nullptr, &console_input_impl_t::on_reply, reply_data("Mouse.RelMotion"));
      });
    }
    void console_input_impl_t::touch(touch_kind_e kind, std::uint64_t slot, double x, double y) {
      if (!multitouch) {
        return;
      }
      enqueue([this, kind, slot, x, y]() {
        qemu_dbus_display1_multi_touch_call_send_event(multitouch, (guint) kind, slot, x, y, G_DBUS_CALL_FLAGS_NONE, timeout_ms, nullptr, &console_input_impl_t::on_reply, reply_data("MultiTouch.SendEvent"));
      });
    }
    bool console_input_impl_t::flush(std::chrono::milliseconds timeout) {
      std::unique_lock lock {pending->mutex};
      return pending->idle.wait_for(lock, timeout, [this]() {
        return pending->count == 0;
      });
    }
    listener_impl_t::listener_impl_t(std::shared_ptr<session_impl_t> session, std::shared_ptr<display_listener_t> listener):
        session {std::move(session)},

@@ -324,6 +324,142 @@
  };
  /**
   * @brief Button values of `org.qemu.Display1.Mouse.Press` and `Release`.
   */
  enum class mouse_button_e : std::uint32_t {
    left = 0,  ///< Left button.
    middle = 1,  ///< Middle button.
    right = 2,  ///< Right button.
    wheel_up = 3,  ///< One wheel step up.
    wheel_down = 4,  ///< One wheel step down.
    side = 5,  ///< Side (back) button.
    extra = 6,  ///< Extra (forward) button.
  };
  /**
   * @brief Event kinds of `org.qemu.Display1.MultiTouch.SendEvent`.
   */
  enum class touch_kind_e : std::uint32_t {
    begin = 0,  ///< A contact starts.
    update = 1,  ///< A contact moves.
    end = 2,  ///< A contact lifts.
    cancel = 3,  ///< A contact is cancelled.
  };
  /**
   * @brief The keyboard, mouse and touch interfaces QEMU exports on one console.
   * @details The input methods never block: calls are queued, sent asynchronously from a GLib
   * thread that makes no blocking calls, and reach QEMU in the order they were made. Errors QEMU
   * returns are logged. The property getters read values cached from `PropertiesChanged`, so they
   * follow the guest (for example `IsAbsolute` when the guest driver switches devices). All
   * methods are thread-safe.
   */
  class console_input_t {
  public:
    virtual ~console_input_t() = default;
    /**
     * @brief Id of the console the input goes to.
     *
     * @return Console id.
     */
    [[nodiscard]] virtual std::uint32_t console_id() const = 0;
    /**
     * @brief Report whether QEMU is still reachable.
     *
     * @return False once the session's bus connection closed or QEMU left the bus.
     */
    [[nodiscard]] virtual bool alive() const = 0;
    /**
     * @brief Current `Mouse.IsAbsolute` property.
     *
     * @return True when the guest uses an absolute pointing device, so `set_abs_position()` works
     * and `rel_motion()` fails; false for relative devices such as a PS/2 mouse.
     */
    [[nodiscard]] virtual bool is_absolute() const = 0;
    /**
     * @brief Report whether the console exports `org.qemu.Display1.MultiTouch`.
     *
     * @return True when touch events can be sent.
     */
    [[nodiscard]] virtual bool has_multitouch() const = 0;
    /**
     * @brief `MultiTouch.MaxSlots` property.
     *
     * @return Number of touch slots, 0 without multi-touch.
     */
    [[nodiscard]] virtual int max_slots() const = 0;
    /**
     * @brief Current console width, from the `Console.Width` property.
     *
     * @return Width in pixels.
     */
    [[nodiscard]] virtual std::uint32_t width() const = 0;
    /**
     * @brief Current console height, from the `Console.Height` property.
     *
     * @return Height in pixels.
     */
    [[nodiscard]] virtual std::uint32_t height() const = 0;
    /**
     * @brief Queue `Keyboard.Press` or `Keyboard.Release`.
     *
     * @param qnum QEMU key number.
     * @param pressed True for a press, false for a release.
     */
    virtual void key(std::uint32_t qnum, bool pressed) = 0;
    /**
     * @brief Queue `Mouse.Press` or `Mouse.Release`.
     *
     * @param button Button.
     * @param pressed True for a press, false for a release.
     */
    virtual void button(mouse_button_e button, bool pressed) = 0;
    /**
     * @brief Queue `Mouse.SetAbsPosition`.
     *
     * @param x X position in console pixels, less than the console width.
     * @param y Y position in console pixels, less than the console height.
     */
    virtual void set_abs_position(std::uint32_t x, std::uint32_t y) = 0;
    /**
     * @brief Queue `Mouse.RelMotion`.
     *
     * @param dx Horizontal motion in pixels.
     * @param dy Vertical motion in pixels.
     */
    virtual void rel_motion(std::int32_t dx, std::int32_t dy) = 0;
    /**
     * @brief Queue `MultiTouch.SendEvent`.
     *
     * @param kind Event kind.
     * @param slot Touch slot, less than `max_slots()`.
     * @param x X position in console pixels.
     * @param y Y position in console pixels.
     */
    virtual void touch(touch_kind_e kind, std::uint64_t slot, double x, double y) = 0;
    /**
     * @brief Wait until QEMU answered every queued call.
     *
     * @param timeout Maximum time to wait.
     * @return True when no call is pending.
     */
    virtual bool flush(std::chrono::milliseconds timeout) = 0;
  };
  /**
   * @brief Registration of a display or audio listener; destroying it unregisters the listener.
   * @details After the destructor returns, no method of the listener is invoked again.
   */
@@ -390,6 +526,16 @@
     * @return Registration handle, or nullptr when QEMU has no D-Bus audio or refused the listener.
     */
    virtual std::unique_ptr<listener_registration_t> register_audio_out_listener(std::shared_ptr<audio_out_listener_t> listener) = 0;
    /**
     * @brief Open the keyboard, mouse and touch interfaces of a console.
     * @details Blocks while the proxies read their properties; the returned object's input
     * methods never block.
     *
     * @param console_id Id of the console to send input to.
     * @return Console input, or nullptr when the console doesn't exist or QEMU is gone.
     */
    virtual std::shared_ptr<console_input_t> open_input(std::uint32_t console_id) = 0;
  };
  /**