Skip to content

Xbox Cloud Gaming app for PS5 Homebrew

C
13.0 KB
Raw Blame
// SPDX-License-Identifier: GPL-3.0-or-later
// Copyright (C) 2026 RafaelNGP
#include "app/web_server.h"
#include "platform/platform.h"

#include <algorithm>
#include <cmath>
#include <cstring>
#include <mbedtls/base64.h>
#include <mbedtls/sha1.h>
#include <mutex>

namespace xc::app {

namespace ws {

std::string computeAccept(const std::string& key) {
    std::string trimmed = key;
    while (!trimmed.empty() && (trimmed.front() == ' ' || trimmed.front() == '\t' || trimmed.front() == '\r' || trimmed.front() == '\n')) {
        trimmed.erase(trimmed.begin());
    }
    while (!trimmed.empty() && (trimmed.back() == ' ' || trimmed.back() == '\t' || trimmed.back() == '\r' || trimmed.back() == '\n')) {
        trimmed.pop_back();
    }
    trimmed += "258EAFA5-E914-47DA-95CA-C5AB0DC85B11";
    unsigned char sha[20];
    mbedtls_sha1(reinterpret_cast<const unsigned char*>(trimmed.data()), trimmed.size(), sha);
    unsigned char b64[64];
    size_t olen = 0;
    mbedtls_base64_encode(b64, sizeof(b64), &olen, sha, sizeof(sha));
    return std::string(reinterpret_cast<char*>(b64), olen);
}

std::vector<uint8_t> makeFrame(Opcode opcode, const uint8_t* data, size_t len, bool fin) {
    std::vector<uint8_t> frame;
    uint8_t b0 = (fin ? 0x80 : 0x00) | (static_cast<uint8_t>(opcode) & 0x0F);
    frame.push_back(b0);
    if (len < 126) {
        frame.push_back(static_cast<uint8_t>(len));
    } else if (len <= 0xFFFF) {
        frame.push_back(126);
        frame.push_back(static_cast<uint8_t>((len >> 8) & 0xFF));
        frame.push_back(static_cast<uint8_t>(len & 0xFF));
    } else {
        frame.push_back(127);
        for (int i = 7; i >= 0; --i) {
            frame.push_back(static_cast<uint8_t>((static_cast<uint64_t>(len) >> (i * 8)) & 0xFF));
        }
    }
    if (data && len > 0) {
        frame.insert(frame.end(), data, data + len);
    }
    return frame;
}

std::vector<uint8_t> makeTextFrame(const std::string& text) {
    return makeFrame(Opcode::Text, reinterpret_cast<const uint8_t*>(text.data()), text.size());
}

std::vector<uint8_t> makeBinaryFrame(const uint8_t* data, size_t len) {
    return makeFrame(Opcode::Binary, data, len);
}

std::vector<uint8_t> makePongFrame(const std::vector<uint8_t>& pingPayload) {
    return makeFrame(Opcode::Pong, pingPayload.data(), pingPayload.size());
}

std::vector<uint8_t> makeCloseFrame(uint16_t code) {
    uint8_t payload[2];
    payload[0] = static_cast<uint8_t>((code >> 8) & 0xFF);
    payload[1] = static_cast<uint8_t>(code & 0xFF);
    return makeFrame(Opcode::Close, payload, sizeof(payload));
}

bool parseFrame(const uint8_t* data, size_t len, Frame& outFrame, size_t& bytesConsumed) {
    if (!data || len < 2) return false;
    bool fin = (data[0] & 0x80) != 0;
    Opcode opcode = static_cast<Opcode>(data[0] & 0x0F);
    bool masked = (data[1] & 0x80) != 0;
    uint8_t lenField = data[1] & 0x7F;

    size_t headerSize = 2;
    uint64_t payloadLen = 0;
    if (lenField < 126) {
        payloadLen = lenField;
    } else if (lenField == 126) {
        if (len < headerSize + 2) return false;
        payloadLen = (static_cast<uint64_t>(data[2]) << 8) | data[3];
        headerSize += 2;
    } else {
        if (len < headerSize + 8) return false;
        payloadLen = 0;
        for (int i = 0; i < 8; ++i) {
            payloadLen = (payloadLen << 8) | data[headerSize + i];
        }
        headerSize += 8;
    }
    if (payloadLen > 1048576) return false;

    uint8_t maskKey[4] = {0, 0, 0, 0};
    if (masked) {
        if (len < headerSize + 4) return false;
        std::memcpy(maskKey, data + headerSize, 4);
        headerSize += 4;
    }

    if (len < headerSize + payloadLen) return false;

    outFrame.fin = fin;
    outFrame.opcode = opcode;
    outFrame.payload.resize(static_cast<size_t>(payloadLen));
    for (size_t i = 0; i < payloadLen; ++i) {
        uint8_t b = data[headerSize + i];
        if (masked) b ^= maskKey[i % 4];
        outFrame.payload[i] = b;
    }
    bytesConsumed = headerSize + static_cast<size_t>(payloadLen);
    return true;
}

}  // namespace ws

bool parseGamepadJson(const json::Value& val, int& outSlot, input::ControllerState& outState) {
    if (!val.isObject()) return false;
    int slot = 0;
    if (val.has("playerIndex")) {
        slot = static_cast<int>(val["playerIndex"].asInt(0));
    } else if (val.has("player")) {
        int p = static_cast<int>(val["player"].asInt(1));
        slot = p - 1;
    }
    slot = std::clamp(slot, 0, 3);
    outSlot = slot;

    outState = input::ControllerState{};
    outState.connected = true;

    auto readButton = [](const json::Value& b) -> bool {
        if (b.isBool()) return b.asBool();
        if (b.isNumber()) return b.asNumber() > 0.5;
        if (b.isObject()) {
            if (b.has("pressed")) return b["pressed"].asBool();
            if (b.has("value")) return b["value"].asNumber() > 0.5;
        }
        return false;
    };

    auto readTrigger = [](const json::Value& b) -> float {
        if (b.isNumber()) return static_cast<float>(b.asNumber(0.0));
        if (b.isBool()) return b.asBool() ? 1.0f : 0.0f;
        if (b.isObject() && b.has("value")) return static_cast<float>(b["value"].asNumber(0.0));
        if (b.isObject() && b.has("pressed")) return b["pressed"].asBool() ? 1.0f : 0.0f;
        return 0.0f;
    };

    // 1. W3C Gamepad API standard arrays
    if (val.has("buttons") && val["buttons"].isArray()) {
        const auto& arr = val["buttons"];
        size_t n = arr.size();
        if (n > 0) outState.btnA = readButton(arr[0]);
        if (n > 1) outState.btnB = readButton(arr[1]);
        if (n > 2) outState.btnX = readButton(arr[2]);
        if (n > 3) outState.btnY = readButton(arr[3]);
        if (n > 4) outState.btnL1 = readButton(arr[4]);
        if (n > 5) outState.btnR1 = readButton(arr[5]);
        if (n > 6) outState.triggerL2 = readTrigger(arr[6]);
        if (n > 7) outState.triggerR2 = readTrigger(arr[7]);
        if (n > 8) outState.btnTouchpad = readButton(arr[8]); // Select / View
        if (n > 9) outState.btnOptions = readButton(arr[9]);   // Start / Menu
        if (n > 10) outState.btnL3 = readButton(arr[10]);
        if (n > 11) outState.btnR3 = readButton(arr[11]);
        if (n > 12) outState.dpadUp = readButton(arr[12]);
        if (n > 13) outState.dpadDown = readButton(arr[13]);
        if (n > 14) outState.dpadLeft = readButton(arr[14]);
        if (n > 15) outState.dpadRight = readButton(arr[15]);
        if (n > 16) outState.btnNexus = readButton(arr[16]);   // Xbox / Guide
    }

    if (val.has("axes") && val["axes"].isArray()) {
        const auto& arr = val["axes"];
        size_t n = arr.size();
        if (n > 0) outState.leftStickX = static_cast<float>(arr[0].asNumber(0.0));
        if (n > 1) outState.leftStickY = static_cast<float>(arr[1].asNumber(0.0));
        if (n > 2) outState.rightStickX = static_cast<float>(arr[2].asNumber(0.0));
        if (n > 3) outState.rightStickY = static_cast<float>(arr[3].asNumber(0.0));
    }

    // 2. Named / object mappings and flat fields
    auto getBool = [&](const char* k1, const char* k2 = nullptr, const char* k3 = nullptr) -> bool {
        if (val.has(k1)) return val[k1].asBool(false);
        if (k2 && val.has(k2)) return val[k2].asBool(false);
        if (k3 && val.has(k3)) return val[k3].asBool(false);
        if (val.has("buttons") && val["buttons"].isObject()) {
            const auto& b = val["buttons"];
            if (b.has(k1)) return b[k1].asBool(false);
            if (k2 && b.has(k2)) return b[k2].asBool(false);
            if (k3 && b.has(k3)) return b[k3].asBool(false);
        }
        return false;
    };

    auto getFloat = [&](const char* k1, const char* k2 = nullptr) -> float {
        if (val.has(k1)) return static_cast<float>(val[k1].asNumber(0.0));
        if (k2 && val.has(k2)) return static_cast<float>(val[k2].asNumber(0.0));
        if (val.has("axes") && val["axes"].isObject()) {
            const auto& a = val["axes"];
            if (a.has(k1)) return static_cast<float>(a[k1].asNumber(0.0));
            if (k2 && a.has(k2)) return static_cast<float>(a[k2].asNumber(0.0));
        }
        return 0.0f;
    };

    if (getBool("btnA", "a")) outState.btnA = true;
    if (getBool("btnB", "b")) outState.btnB = true;
    if (getBool("btnX", "x")) outState.btnX = true;
    if (getBool("btnY", "y")) outState.btnY = true;

    if (getBool("dpadUp", "dpad_up", "up")) outState.dpadUp = true;
    if (getBool("dpadDown", "dpad_down", "down")) outState.dpadDown = true;
    if (getBool("dpadLeft", "dpad_left", "left")) outState.dpadLeft = true;
    if (getBool("dpadRight", "dpad_right", "right")) outState.dpadRight = true;

    if (getBool("btnL1", "lb", "l1")) outState.btnL1 = true;
    if (getBool("btnR1", "rb", "r1")) outState.btnR1 = true;
    if (getBool("btnL3", "ls", "l3")) outState.btnL3 = true;
    if (getBool("btnR3", "rs", "r3")) outState.btnR3 = true;

    if (getBool("btnTouchpad", "btnView", "view")) outState.btnTouchpad = true;
    if (getBool("btnOptions", "btnMenu", "menu")) outState.btnOptions = true;
    if (getBool("btnNexus", "xbox", "guide")) outState.btnNexus = true;

    float tL = getFloat("triggerL2", "lt");
    if (tL > 0.0f) outState.triggerL2 = tL;
    float tR = getFloat("triggerR2", "rt");
    if (tR > 0.0f) outState.triggerR2 = tR;

    if (val.has("leftStickX") || val.has("lx") || (val.has("axes") && val["axes"].isObject())) {
        float lx = getFloat("leftStickX", "lx");
        if (std::abs(lx) > 0.001f) outState.leftStickX = lx;
    }
    if (val.has("leftStickY") || val.has("ly") || (val.has("axes") && val["axes"].isObject())) {
        float ly = getFloat("leftStickY", "ly");
        if (std::abs(ly) > 0.001f) outState.leftStickY = ly;
    }
    if (val.has("rightStickX") || val.has("rx") || (val.has("axes") && val["axes"].isObject())) {
        float rx = getFloat("rightStickX", "rx");
        if (std::abs(rx) > 0.001f) outState.rightStickX = rx;
    }
    if (val.has("rightStickY") || val.has("ry") || (val.has("axes") && val["axes"].isObject())) {
        float ry = getFloat("rightStickY", "ry");
        if (std::abs(ry) > 0.001f) outState.rightStickY = ry;
    }

    outState.rawLeftX = outState.leftStickX;
    outState.rawLeftY = outState.leftStickY;
    outState.rawRightX = outState.rightStickX;
    outState.rawRightY = outState.rightStickY;
    return true;
}

namespace {
struct VirtualGamepadSlot {
    input::ControllerState state{};
    uint64_t lastSeenMs = 0;
    uint64_t lastInputMs = 0;
};
std::mutex s_vpadMutex;
VirtualGamepadSlot s_virtualPads[4];

bool hasGamepadInput(const input::ControllerState& s) {
    return s.btnA || s.btnB || s.btnX || s.btnY ||
           s.dpadUp || s.dpadDown || s.dpadLeft || s.dpadRight ||
           s.btnL1 || s.btnR1 || s.btnL3 || s.btnR3 ||
           s.btnTouchpad || s.btnOptions || s.btnNexus ||
           s.triggerL2 > 0.05f || s.triggerR2 > 0.05f ||
           std::abs(s.leftStickX) > 0.08f || std::abs(s.leftStickY) > 0.08f ||
           std::abs(s.rightStickX) > 0.08f || std::abs(s.rightStickY) > 0.08f;
}
}  // namespace

bool virtualGamepadState(int playerIndex, input::ControllerState& outState, bool& isConnected) {
    if (playerIndex < 0 || playerIndex >= 4) {
        isConnected = false;
        outState = {};
        return false;
    }
    std::lock_guard<std::mutex> lock(s_vpadMutex);
    uint64_t now = platform::nowMs();
    uint64_t diff = now > s_virtualPads[playerIndex].lastSeenMs ? now - s_virtualPads[playerIndex].lastSeenMs : 0;
    isConnected = (s_virtualPads[playerIndex].lastSeenMs > 0 && diff < 4000);
    if (diff < 2000) {
        outState = s_virtualPads[playerIndex].state;
    } else {
        outState = {};
    }
    return isConnected;
}

void setVirtualGamepad(int playerIndex, const input::ControllerState& state) {
    if (playerIndex < 0 || playerIndex >= 4) return;
    std::lock_guard<std::mutex> lock(s_vpadMutex);
    uint64_t now = platform::nowMs();
    bool firstSeen = (s_virtualPads[playerIndex].lastSeenMs == 0);
    s_virtualPads[playerIndex].state = state;
    s_virtualPads[playerIndex].lastSeenMs = now;
    if (firstSeen || hasGamepadInput(state)) {
        s_virtualPads[playerIndex].lastInputMs = now;
    }
}

void touchVirtualGamepad(int playerIndex) {
    if (playerIndex < 0 || playerIndex >= 4) return;
    std::lock_guard<std::mutex> lock(s_vpadMutex);
    uint64_t now = platform::nowMs();
    s_virtualPads[playerIndex].lastSeenMs = now;
    s_virtualPads[playerIndex].lastInputMs = now;
}

void switchVirtualGamepadSlot(int newSlot) {
    if (newSlot < 0 || newSlot >= 4) return;
    std::lock_guard<std::mutex> lock(s_vpadMutex);
    for (int i = 0; i < 4; ++i) {
        if (i != newSlot) {
            s_virtualPads[i] = {};
        }
    }
    uint64_t now = platform::nowMs();
    s_virtualPads[newSlot].lastSeenMs = now;
    s_virtualPads[newSlot].lastInputMs = now;
}

uint64_t virtualGamepadActiveAt(int playerIndex) {
    if (playerIndex < 0 || playerIndex >= 4) return 0;
    std::lock_guard<std::mutex> lock(s_vpadMutex);
    return s_virtualPads[playerIndex].lastInputMs;
}

void resetVirtualGamepads() {
    std::lock_guard<std::mutex> lock(s_vpadMutex);
    for (auto& slot : s_virtualPads) slot = {};
}

}  // namespace xc::app