Skip to content

Bring PS5 GTA6 to 120FPS with DLSS 5. An advanced Windows video player and capture enhancement tool featuring real-time preview for videos, images, and capture card sources. Combine AI-powered Super Resolution, DLSS5 image enhancement, and Frame Generation to deliver a next-generation visual experience.

C++
6.4 KB
Raw Blame
// Headless Remote Play probe: drives the exact product session stack with a
// saved (already paired) profile so codec/bitrate variables can be compared
// without the GUI. It never prints credentials.
#include "veyra/remoteplay/ProfileStore.h"
#include "veyra/source/RemotePlaySessionSource.h"
#include "veyra/gfx/D3D12DeviceContext.h"
#include "veyra/Log.h"

#include <chrono>
#include <filesystem>
#include <iostream>
#include <string>
#include <thread>

using namespace veyra;

namespace {

std::string narrow(const std::wstring& value) {
    if (value.empty()) return {};
    const int size = WideCharToMultiByte(CP_UTF8, 0, value.c_str(), int(value.size()), nullptr, 0, nullptr, nullptr);
    std::string result(size_t(size), '\0');
    WideCharToMultiByte(CP_UTF8, 0, value.c_str(), int(value.size()), result.data(), size, nullptr, nullptr);
    return result;
}

const char* stateName(remoteplay::SessionState state) {
    switch (state) {
    case remoteplay::SessionState::Idle: return "idle";
    case remoteplay::SessionState::Connecting: return "connecting";
    case remoteplay::SessionState::WaitingFirstFrame: return "waiting-first-frame";
    case remoteplay::SessionState::Streaming: return "streaming";
    case remoteplay::SessionState::LoginPinRequired: return "login-pin-required";
    case remoteplay::SessionState::Failed: return "failed";
    case remoteplay::SessionState::Stopping: return "stopping";
    }
    return "?";
}

} // namespace

int wmain(int argc, wchar_t** argv) {
    std::string codec = "keep";
    unsigned bitrate = 0;
    int seconds = 20;
    std::filesystem::path profile;
    for (int i = 1; i < argc; ++i) {
        const std::wstring arg = argv[i];
        if (arg == L"--codec" && i + 1 < argc) codec = narrow(argv[++i]);
        else if (arg == L"--bitrate" && i + 1 < argc) bitrate = unsigned(wcstoul(argv[++i], nullptr, 10));
        else if (arg == L"--seconds" && i + 1 < argc) seconds = _wtoi(argv[++i]);
        else if (arg == L"--profile" && i + 1 < argc) profile = argv[++i];
    }
    if (profile.empty()) {
        // The GUI saves one <32-hex-account-id>.dat per paired console; fall
        // back to the first one when the caller does not name a profile.
        const auto directory = remoteplay::profileDirectory();
        profile = directory / L"remoteplay-profile.dat";
        if (!std::filesystem::exists(profile)) {
            std::error_code error;
            for (const auto& entry : std::filesystem::directory_iterator(directory, error)) {
                const auto stem = entry.path().stem().wstring();
                const bool hex = stem.size() == 32 && std::all_of(stem.begin(), stem.end(), [](wchar_t c) {
                    return (c >= L'0' && c <= L'9') || (c >= L'a' && c <= L'f');
                });
                if (hex && entry.path().extension() == L".dat") { profile = entry.path(); break; }
            }
        }
    }
    std::cout << "profile=" << profile.string() << "\n";
    auto request = remoteplay::loadProfile(profile);
    if (!request) { std::cout << "PROBE profile-unavailable\n"; return 2; }
    if (codec == "h264") request->video.codec = remoteplay::Codec::H264;
    else if (codec == "h265") request->video.codec = remoteplay::Codec::H265;
    else if (codec == "h265hdr") request->video.codec = remoteplay::Codec::H265Hdr;
    if (bitrate != 0) request->video.bitrateKbps = bitrate;
    std::cout << "host=" << request->host << " codec=" << int(request->video.codec)
        << " bitrate=" << request->video.bitrateKbps << " profile=" << request->video.width << "x"
        << request->video.height << "@" << request->video.fps << "\n";

    gfx::D3D12DeviceContext context;
    gfx::DeviceContextDesc desc;
    Status status;
    if (!context.initialize(desc, status)) { std::cout << "PROBE no-d3d12\n"; return 3; }
    context.device()->AddRef();

    source::RemotePlayConnectDesc connect;
    connect.request = std::move(*request);
    connect.decodeMode = source::RemotePlayConnectDesc::DecodeMode::Automatic;
    connect.decodeDevice = std::shared_ptr<ID3D12Device>(context.device(), [](ID3D12Device* device) { device->Release(); });

    source::RemotePlaySessionSource session;
    if (!session.connect(std::move(connect))) { std::cout << "PROBE connect-refused\n"; return 4; }

    pipeline::FramePacket packet;
    const AVFrame* frame = nullptr;
    uint64_t frames = 0;
    int lastState = -1;
    std::wstring lastMessage;
    const auto deadline = std::chrono::steady_clock::now() + std::chrono::seconds(seconds);
    while (std::chrono::steady_clock::now() < deadline) {
        const auto result = session.read(packet, &frame);
        if (result == source::SourceReadStatus::Frame) ++frames;
        else if (result == source::SourceReadStatus::Error) break;
        const auto snapshot = session.sessionSnapshot();
        if (int(snapshot.state) != lastState) {
            lastState = int(snapshot.state);
            std::cout << "state=" << stateName(snapshot.state) << " t="
                << std::chrono::duration_cast<std::chrono::seconds>(std::chrono::steady_clock::now() - (deadline - std::chrono::seconds(seconds))).count() << "s\n";
        }
        if (snapshot.state == remoteplay::SessionState::LoginPinRequired) { std::cout << "PROBE pin-required\n"; break; }
        // A Failed session state must NOT end the probe: the recovery layer owns
        // the retry (including the RP_IN_USE backoff), so the deadline decides.
        const auto recovery = session.recoveryStatus();
        if (recovery.active && recovery.message != lastMessage) {
            lastMessage = recovery.message;
            std::wcout << L"recovery: " << recovery.message << L"\n";
        }
        std::this_thread::sleep_for(std::chrono::milliseconds(5));
    }
    const auto snapshot = session.sessionSnapshot();
    std::cout << "RESULT frames=" << frames << " state=" << stateName(snapshot.state)
        << " received=" << snapshot.video.accessUnits << " decoded=" << snapshot.decodedFrames
        << " waitingIdr=" << (snapshot.video.waitingForIdr ? 1 : 0) << " idrRequests=" << snapshot.video.idrRequests
        << " errorCode=" << snapshot.errorCode << " recoveredFrames=" << snapshot.framesLost
        << " hwDecode=" << (snapshot.hardwareDecode ? 1 : 0) << " decodeFallback=" << (snapshot.decodeFallback ? 1 : 0) << "\n";
    const auto recovery = session.recoveryStatus();
    if (!recovery.message.empty()) std::wcout << L"recovery: " << recovery.message << L"\n";
    session.close();
    return frames > 30 ? 0 : 1;
}