mirror of
https://github.com/moonlight-stream/moonlight-qt
synced 2024-12-14 05:12:27 +00:00
0ab07303c9
* Add quit cli command and app quit option after stream session. Fixes #92 * Code review fixes.
226 lines
8 KiB
C++
226 lines
8 KiB
C++
#include "streamingpreferences.h"
|
|
#include "streaming/session.h"
|
|
#include "streaming/streamutils.h"
|
|
|
|
#include <QSettings>
|
|
|
|
#define SER_STREAMSETTINGS "streamsettings"
|
|
#define SER_WIDTH "width"
|
|
#define SER_HEIGHT "height"
|
|
#define SER_FPS "fps"
|
|
#define SER_BITRATE "bitrate"
|
|
#define SER_FULLSCREEN "fullscreen"
|
|
#define SER_VSYNC "vsync"
|
|
#define SER_GAMEOPTS "gameopts"
|
|
#define SER_HOSTAUDIO "hostaudio"
|
|
#define SER_MULTICONT "multicontroller"
|
|
#define SER_AUDIOCFG "audiocfg"
|
|
#define SER_VIDEOCFG "videocfg"
|
|
#define SER_VIDEODEC "videodec"
|
|
#define SER_WINDOWMODE "windowmode"
|
|
#define SER_UNSUPPORTEDFPS "unsupportedfps"
|
|
#define SER_MDNS "mdns"
|
|
#define SER_QUITAPPAFTER "quitAppAfter"
|
|
#define SER_MOUSEACCELERATION "mouseacceleration"
|
|
#define SER_STARTWINDOWED "startwindowed"
|
|
|
|
StreamingPreferences::StreamingPreferences(QObject *parent)
|
|
: QObject(parent)
|
|
{
|
|
reload();
|
|
}
|
|
|
|
void StreamingPreferences::reload()
|
|
{
|
|
QSettings settings;
|
|
|
|
width = settings.value(SER_WIDTH, 1280).toInt();
|
|
height = settings.value(SER_HEIGHT, 720).toInt();
|
|
fps = settings.value(SER_FPS, 60).toInt();
|
|
bitrateKbps = settings.value(SER_BITRATE, getDefaultBitrate(width, height, fps)).toInt();
|
|
enableVsync = settings.value(SER_VSYNC, true).toBool();
|
|
gameOptimizations = settings.value(SER_GAMEOPTS, true).toBool();
|
|
playAudioOnHost = settings.value(SER_HOSTAUDIO, false).toBool();
|
|
multiController = settings.value(SER_MULTICONT, true).toBool();
|
|
unsupportedFps = settings.value(SER_UNSUPPORTEDFPS, false).toBool();
|
|
enableMdns = settings.value(SER_MDNS, true).toBool();
|
|
quitAppAfter = settings.value(SER_QUITAPPAFTER, false).toBool();
|
|
mouseAcceleration = settings.value(SER_MOUSEACCELERATION, false).toBool();
|
|
startWindowed = settings.value(SER_STARTWINDOWED, false).toBool();
|
|
audioConfig = static_cast<AudioConfig>(settings.value(SER_AUDIOCFG,
|
|
static_cast<int>(AudioConfig::AC_STEREO)).toInt());
|
|
videoCodecConfig = static_cast<VideoCodecConfig>(settings.value(SER_VIDEOCFG,
|
|
static_cast<int>(VideoCodecConfig::VCC_AUTO)).toInt());
|
|
videoDecoderSelection = static_cast<VideoDecoderSelection>(settings.value(SER_VIDEODEC,
|
|
static_cast<int>(VideoDecoderSelection::VDS_AUTO)).toInt());
|
|
windowMode = static_cast<WindowMode>(settings.value(SER_WINDOWMODE,
|
|
// Try to load from the old preference value too
|
|
static_cast<int>(settings.value(SER_FULLSCREEN, true).toBool() ?
|
|
WindowMode::WM_FULLSCREEN : WindowMode::WM_WINDOWED)).toInt());
|
|
}
|
|
|
|
void StreamingPreferences::save()
|
|
{
|
|
QSettings settings;
|
|
|
|
settings.setValue(SER_WIDTH, width);
|
|
settings.setValue(SER_HEIGHT, height);
|
|
settings.setValue(SER_FPS, fps);
|
|
settings.setValue(SER_BITRATE, bitrateKbps);
|
|
settings.setValue(SER_VSYNC, enableVsync);
|
|
settings.setValue(SER_GAMEOPTS, gameOptimizations);
|
|
settings.setValue(SER_HOSTAUDIO, playAudioOnHost);
|
|
settings.setValue(SER_MULTICONT, multiController);
|
|
settings.setValue(SER_UNSUPPORTEDFPS, unsupportedFps);
|
|
settings.setValue(SER_MDNS, enableMdns);
|
|
settings.setValue(SER_QUITAPPAFTER, quitAppAfter);
|
|
settings.setValue(SER_MOUSEACCELERATION, mouseAcceleration);
|
|
settings.setValue(SER_STARTWINDOWED, startWindowed);
|
|
settings.setValue(SER_AUDIOCFG, static_cast<int>(audioConfig));
|
|
settings.setValue(SER_VIDEOCFG, static_cast<int>(videoCodecConfig));
|
|
settings.setValue(SER_VIDEODEC, static_cast<int>(videoDecoderSelection));
|
|
settings.setValue(SER_WINDOWMODE, static_cast<int>(windowMode));
|
|
}
|
|
|
|
bool StreamingPreferences::hasAnyHardwareAcceleration()
|
|
{
|
|
// Always use VDS_AUTO to avoid spamming the user with warnings
|
|
// if they've forced software decoding.
|
|
return Session::isHardwareDecodeAvailable(VDS_AUTO,
|
|
VIDEO_FORMAT_H264,
|
|
1920, 1080, 60);
|
|
}
|
|
|
|
bool StreamingPreferences::isRunningWayland()
|
|
{
|
|
return qgetenv("XDG_SESSION_TYPE") == QByteArray("wayland");
|
|
}
|
|
|
|
bool StreamingPreferences::isWow64()
|
|
{
|
|
#ifdef Q_OS_WIN32
|
|
return QSysInfo::currentCpuArchitecture() != QSysInfo::buildCpuArchitecture();
|
|
#else
|
|
return false;
|
|
#endif
|
|
}
|
|
|
|
QString StreamingPreferences::getUnmappedGamepads()
|
|
{
|
|
return SdlInputHandler::getUnmappedGamepads();
|
|
}
|
|
|
|
int StreamingPreferences::getMaximumStreamingFrameRate()
|
|
{
|
|
// Never let the maximum drop below 60 FPS
|
|
int maxFrameRate = 60;
|
|
|
|
if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
|
|
"SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
|
|
SDL_GetError());
|
|
return maxFrameRate;
|
|
}
|
|
|
|
SDL_DisplayMode mode, bestMode, desktopMode;
|
|
for (int displayIndex = 0; displayIndex < SDL_GetNumVideoDisplays(); displayIndex++) {
|
|
// Get the native desktop resolution
|
|
if (StreamUtils::getRealDesktopMode(displayIndex, &desktopMode)) {
|
|
|
|
// Start at desktop mode and work our way up
|
|
bestMode = desktopMode;
|
|
for (int i = 0; i < SDL_GetNumDisplayModes(displayIndex); i++) {
|
|
if (SDL_GetDisplayMode(displayIndex, i, &mode) == 0) {
|
|
if (mode.w == desktopMode.w && mode.h == desktopMode.h) {
|
|
if (mode.refresh_rate > bestMode.refresh_rate) {
|
|
bestMode = mode;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
maxFrameRate = qMax(maxFrameRate, bestMode.refresh_rate);
|
|
}
|
|
}
|
|
|
|
SDL_QuitSubSystem(SDL_INIT_VIDEO);
|
|
|
|
return maxFrameRate;
|
|
}
|
|
|
|
QRect StreamingPreferences::getDesktopResolution(int displayIndex)
|
|
{
|
|
if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
|
|
"SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
|
|
SDL_GetError());
|
|
return QRect();
|
|
}
|
|
|
|
if (displayIndex >= SDL_GetNumVideoDisplays()) {
|
|
SDL_QuitSubSystem(SDL_INIT_VIDEO);
|
|
return QRect();
|
|
}
|
|
|
|
SDL_DisplayMode mode;
|
|
int err = SDL_GetDesktopDisplayMode(displayIndex, &mode);
|
|
SDL_QuitSubSystem(SDL_INIT_VIDEO);
|
|
|
|
if (err == 0) {
|
|
return QRect(0, 0, mode.w, mode.h);
|
|
}
|
|
else {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
|
|
"SDL_GetDesktopDisplayMode() failed: %s",
|
|
SDL_GetError());
|
|
return QRect();
|
|
}
|
|
}
|
|
|
|
QRect StreamingPreferences::getNativeResolution(int displayIndex)
|
|
{
|
|
if (SDL_InitSubSystem(SDL_INIT_VIDEO) != 0) {
|
|
SDL_LogError(SDL_LOG_CATEGORY_APPLICATION,
|
|
"SDL_InitSubSystem(SDL_INIT_VIDEO) failed: %s",
|
|
SDL_GetError());
|
|
return QRect();
|
|
}
|
|
|
|
if (displayIndex >= SDL_GetNumVideoDisplays()) {
|
|
SDL_QuitSubSystem(SDL_INIT_VIDEO);
|
|
return QRect();
|
|
}
|
|
|
|
SDL_DisplayMode mode;
|
|
bool success = StreamUtils::getRealDesktopMode(displayIndex, &mode);
|
|
SDL_QuitSubSystem(SDL_INIT_VIDEO);
|
|
|
|
if (success) {
|
|
return QRect(0, 0, mode.w, mode.h);
|
|
}
|
|
else {
|
|
return QRect();
|
|
}
|
|
}
|
|
|
|
int StreamingPreferences::getDefaultBitrate(int width, int height, int fps)
|
|
{
|
|
// This table prefers 16:10 resolutions because they are
|
|
// only slightly more pixels than the 16:9 equivalents, so
|
|
// we don't want to bump those 16:10 resolutions up to the
|
|
// next 16:9 slot.
|
|
|
|
// This covers 1280x720 and 1280x800 too
|
|
if (width * height <= 1366 * 768) {
|
|
return static_cast<int>(5000 * (fps / 30.0));
|
|
}
|
|
else if (width * height <= 1920 * 1200) {
|
|
return static_cast<int>(10000 * (fps / 30.0));
|
|
}
|
|
else if (width * height <= 2560 * 1600) {
|
|
return static_cast<int>(20000 * (fps / 30.0));
|
|
}
|
|
else /* if (width * height <= 3840 * 2160) */ {
|
|
return static_cast<int>(40000 * (fps / 30.0));
|
|
}
|
|
}
|