mirror of
https://github.com/obsproject/obs-studio.git
synced 2024-07-19 09:39:15 +00:00
432 lines
11 KiB
C++
432 lines
11 KiB
C++
/******************************************************************************
|
|
Copyright (C) 2013 by Hugh Bailey <obs.jim@gmail.com>
|
|
|
|
This program is free software: you can redistribute it and/or modify
|
|
it under the terms of the GNU General Public License as published by
|
|
the Free Software Foundation, either version 2 of the License, or
|
|
(at your option) any later version.
|
|
|
|
This program is distributed in the hope that it will be useful,
|
|
but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
GNU General Public License for more details.
|
|
|
|
You should have received a copy of the GNU General Public License
|
|
along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
******************************************************************************/
|
|
|
|
#include <util/lexer.h>
|
|
|
|
#include "obs-app.hpp"
|
|
#include "settings-basic.hpp"
|
|
#include "window-basic-settings.hpp"
|
|
#include "wx-wrappers.hpp"
|
|
#include "platform.hpp"
|
|
|
|
#include <sstream>
|
|
#include <unordered_set>
|
|
using namespace std;
|
|
|
|
class BasicVideoData : public BasicSettingsData {
|
|
ConnectorList connections;
|
|
|
|
int AddRes(uint32_t cx, uint32_t cy);
|
|
void LoadOther();
|
|
void LoadResolutionData();
|
|
void LoadFPSData();
|
|
void LoadFPSCommon();
|
|
void LoadFPSInteger();
|
|
void LoadFPSFraction();
|
|
void LoadFPSNanoseconds();
|
|
void ResetScaleList(uint32_t cx, uint32_t cy);
|
|
|
|
void RendererChanged(wxCommandEvent &event);
|
|
void BaseResChanged(wxCommandEvent &event);
|
|
void OutputResChanged(wxCommandEvent &event);
|
|
void FPSChanged(wxCommandEvent &event);
|
|
|
|
void SaveOther();
|
|
void SaveFPSData();
|
|
void SaveFPSCommon();
|
|
void SaveFPSInteger();
|
|
void SaveFPSFraction();
|
|
void SaveFPSNanoseconds();
|
|
|
|
virtual void SetChanged()
|
|
{
|
|
BasicSettingsData::SetChanged();
|
|
window->videoChangedText->Show();
|
|
}
|
|
|
|
public:
|
|
BasicVideoData(OBSBasicSettings *window);
|
|
|
|
virtual void Apply();
|
|
};
|
|
|
|
struct BaseLexer {
|
|
lexer lex;
|
|
public:
|
|
inline BaseLexer() {lexer_init(&lex);}
|
|
inline ~BaseLexer() {lexer_free(&lex);}
|
|
operator lexer*() {return &lex;}
|
|
};
|
|
|
|
/* parses "[width]x[height]", string, i.e. 1024x768 */
|
|
static bool ConvertTextRes(wxComboBox *combo, uint32_t &cx, uint32_t &cy)
|
|
{
|
|
string str = combo->GetValue().ToStdString();
|
|
|
|
BaseLexer lex;
|
|
lexer_start(lex, str.c_str());
|
|
|
|
base_token token;
|
|
|
|
/* parse width */
|
|
if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
|
|
return false;
|
|
if (token.type != BASETOKEN_DIGIT)
|
|
return false;
|
|
|
|
cx = std::stoul(token.text.array);
|
|
|
|
/* parse 'x' */
|
|
if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
|
|
return false;
|
|
if (strref_cmpi(&token.text, "x") != 0)
|
|
return false;
|
|
|
|
/* parse height */
|
|
if (!lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
|
|
return false;
|
|
if (token.type != BASETOKEN_DIGIT)
|
|
return false;
|
|
|
|
cy = std::stoul(token.text.array);
|
|
|
|
/* shouldn't be any more tokens after this */
|
|
if (lexer_getbasetoken(lex, &token, IGNORE_WHITESPACE))
|
|
return false;
|
|
|
|
return true;
|
|
}
|
|
|
|
int BasicVideoData::AddRes(uint32_t cx, uint32_t cy)
|
|
{
|
|
stringstream res;
|
|
res << cx << "x" << cy;
|
|
return window->baseResList->Append(res.str());
|
|
}
|
|
|
|
void BasicVideoData::LoadOther()
|
|
{
|
|
const char *renderer = config_get_string(GetGlobalConfig(), "Video",
|
|
"Renderer");
|
|
|
|
window->rendererList->Clear();
|
|
window->rendererList->Append("OpenGL");
|
|
#ifdef _WIN32
|
|
window->rendererList->Append("Direct3D 11");
|
|
#endif
|
|
|
|
int sel = window->rendererList->FindString(renderer);
|
|
if (sel == wxNOT_FOUND)
|
|
sel = 0;
|
|
|
|
window->rendererList->SetSelection(sel);
|
|
}
|
|
|
|
static uint64_t append_uint32_t(uint64_t first, uint64_t second)
|
|
{
|
|
return (first << 32) | second;
|
|
}
|
|
|
|
void BasicVideoData::LoadResolutionData()
|
|
{
|
|
window->baseResList->Clear();
|
|
|
|
uint32_t cx = config_get_uint(GetGlobalConfig(), "Video", "BaseCX");
|
|
uint32_t cy = config_get_uint(GetGlobalConfig(), "Video", "BaseCY");
|
|
|
|
vector<MonitorInfo> monitors;
|
|
GetMonitors(monitors);
|
|
unordered_set<uint64_t> resolutions;
|
|
for (size_t i = 0; i < monitors.size(); i++) {
|
|
uint64_t res = append_uint32_t(monitors[i].cx, monitors[i].cy);
|
|
if(resolutions.emplace(res).second)
|
|
AddRes(monitors[i].cx, monitors[i].cy);
|
|
}
|
|
|
|
stringstream res;
|
|
res << cx << "x" << cy;
|
|
window->baseResList->SetValue(res.str());
|
|
|
|
ResetScaleList(cx, cy);
|
|
|
|
cx = config_get_uint(GetGlobalConfig(), "Video", "OutputCX");
|
|
cy = config_get_uint(GetGlobalConfig(), "Video", "OutputCY");
|
|
|
|
res.str(string());
|
|
res.clear();
|
|
res << cx << "x" << cy;
|
|
window->outputResList->SetValue(res.str());
|
|
}
|
|
|
|
void BasicVideoData::LoadFPSData()
|
|
{
|
|
const char *fpsType = config_get_string(GetGlobalConfig(), "Video",
|
|
"FPSType");
|
|
|
|
LoadFPSCommon();
|
|
LoadFPSInteger();
|
|
LoadFPSFraction();
|
|
LoadFPSNanoseconds();
|
|
|
|
if (!fpsType)
|
|
return;
|
|
else if (strcmp(fpsType, "Common") == 0)
|
|
window->fpsTypeList->SetSelection(0);
|
|
else if (strcmp(fpsType, "Integer") == 0)
|
|
window->fpsTypeList->SetSelection(1);
|
|
else if (strcmp(fpsType, "Fraction") == 0)
|
|
window->fpsTypeList->SetSelection(2);
|
|
else if (strcmp(fpsType, "Nanoseconds") == 0)
|
|
window->fpsTypeList->SetSelection(3);
|
|
}
|
|
|
|
void BasicVideoData::LoadFPSCommon()
|
|
{
|
|
const char *val = config_get_string(GetGlobalConfig(), "Video",
|
|
"FPSCommon");
|
|
|
|
int sel = window->fpsCommonList->FindString(val);
|
|
if (sel == wxNOT_FOUND)
|
|
sel = window->fpsCommonList->FindString("30");
|
|
window->fpsCommonList->SetSelection(sel);
|
|
}
|
|
|
|
void BasicVideoData::LoadFPSInteger()
|
|
{
|
|
window->fpsTypeList->SetSelection(1);
|
|
|
|
int val = config_get_int(GetGlobalConfig(), "Video", "FPSInt");
|
|
window->fpsIntegerScroller->SetValue(val);
|
|
}
|
|
|
|
void BasicVideoData::LoadFPSFraction()
|
|
{
|
|
window->fpsTypeList->SetSelection(2);
|
|
|
|
int num = config_get_int(GetGlobalConfig(), "Video", "FPSNum");
|
|
int den = config_get_int(GetGlobalConfig(), "Video", "FPSDen");
|
|
|
|
window->fpsNumeratorScroller->SetValue(num);
|
|
window->fpsDenominatorScroller->SetValue(den);
|
|
}
|
|
|
|
void BasicVideoData::LoadFPSNanoseconds()
|
|
{
|
|
window->fpsTypeList->SetSelection(3);
|
|
|
|
int val = config_get_int(GetGlobalConfig(), "Video", "FPSNS");
|
|
window->fpsNanosecondsScroller->SetValue(val);
|
|
}
|
|
|
|
/* some nice default output resolution vals */
|
|
static const double vals[] =
|
|
{
|
|
1.0,
|
|
1.25,
|
|
(1.0/0.75),
|
|
1.5,
|
|
(1.0/0.6),
|
|
1.75,
|
|
2.0,
|
|
2.25,
|
|
2.5,
|
|
2.75,
|
|
3.0
|
|
};
|
|
|
|
static const size_t numVals = sizeof(vals)/sizeof(double);
|
|
|
|
void BasicVideoData::ResetScaleList(uint32_t cx, uint32_t cy)
|
|
{
|
|
window->outputResList->Clear();
|
|
|
|
for (size_t i = 0; i < numVals; i++) {
|
|
stringstream res;
|
|
res << uint32_t(double(cx) / vals[i]);
|
|
res << "x";
|
|
res << uint32_t(double(cy) / vals[i]);
|
|
window->outputResList->Append(res.str());
|
|
}
|
|
|
|
if (numVals) {
|
|
stringstream str;
|
|
str << cx << "x" << cy;
|
|
window->outputResList->SetValue(str.str());
|
|
}
|
|
}
|
|
|
|
#define ADD_CONNECT(control, event, func) \
|
|
connections.Add(window->control, event, \
|
|
wxCommandEventHandler(BasicVideoData::func), \
|
|
NULL, this)
|
|
|
|
BasicVideoData::BasicVideoData(OBSBasicSettings *window)
|
|
: BasicSettingsData(window)
|
|
{
|
|
LoadResolutionData();
|
|
LoadFPSData();
|
|
LoadOther();
|
|
|
|
/* load connectors after loading data to prevent them from triggering */
|
|
ADD_CONNECT(baseResList, wxEVT_TEXT, BaseResChanged);
|
|
ADD_CONNECT(outputResList, wxEVT_TEXT, OutputResChanged);
|
|
ADD_CONNECT(rendererList, wxEVT_COMBOBOX, RendererChanged);
|
|
ADD_CONNECT(fpsCommonList, wxEVT_COMBOBOX, FPSChanged);
|
|
ADD_CONNECT(fpsIntegerScroller, wxEVT_SPINCTRL, FPSChanged);
|
|
ADD_CONNECT(fpsNumeratorScroller, wxEVT_SPINCTRL, FPSChanged);
|
|
ADD_CONNECT(fpsDenominatorScroller, wxEVT_SPINCTRL, FPSChanged);
|
|
ADD_CONNECT(fpsNanosecondsScroller, wxEVT_SPINCTRL, FPSChanged);
|
|
ADD_CONNECT(fpsIntegerScroller, wxEVT_TEXT, FPSChanged);
|
|
ADD_CONNECT(fpsNumeratorScroller, wxEVT_TEXT, FPSChanged);
|
|
ADD_CONNECT(fpsDenominatorScroller, wxEVT_TEXT, FPSChanged);
|
|
ADD_CONNECT(fpsNanosecondsScroller, wxEVT_TEXT, FPSChanged);
|
|
ADD_CONNECT(fpsTypeList, wxEVT_CHOICEBOOK_PAGE_CHANGED,
|
|
FPSChanged);
|
|
|
|
window->videoChangedText->Hide();
|
|
}
|
|
|
|
void BasicVideoData::RendererChanged(wxCommandEvent &event)
|
|
{
|
|
SetChanged();
|
|
window->videoChangedText->SetLabel(WXStr("Settings.ProgramRestart"));
|
|
window->videoChangedText->Show();
|
|
}
|
|
|
|
void BasicVideoData::FPSChanged(wxCommandEvent &event)
|
|
{
|
|
SetChanged();
|
|
}
|
|
|
|
void BasicVideoData::BaseResChanged(wxCommandEvent &event)
|
|
{
|
|
uint32_t cx, cy;
|
|
if (!ConvertTextRes(window->baseResList, cx, cy)) {
|
|
window->videoChangedText->SetLabel(
|
|
WXStr("Settings.Video.InvalidResolution"));
|
|
window->videoChangedText->Show();
|
|
return;
|
|
}
|
|
|
|
SetChanged();
|
|
|
|
ResetScaleList(cx, cy);
|
|
}
|
|
|
|
void BasicVideoData::OutputResChanged(wxCommandEvent &event)
|
|
{
|
|
uint32_t cx, cy;
|
|
if (!ConvertTextRes(window->outputResList, cx, cy)) {
|
|
window->videoChangedText->SetLabel(
|
|
WXStr("Settings.Video.InvalidResolution"));
|
|
window->videoChangedText->Show();
|
|
return;
|
|
}
|
|
|
|
SetChanged();
|
|
}
|
|
|
|
void BasicVideoData::SaveOther()
|
|
{
|
|
int sel = window->rendererList->GetSelection();
|
|
if (sel == wxNOT_FOUND)
|
|
return;
|
|
|
|
wxString renderer = window->rendererList->GetString(sel);
|
|
config_set_string(GetGlobalConfig(), "Video", "Renderer",
|
|
renderer.c_str());
|
|
}
|
|
|
|
void BasicVideoData::SaveFPSData()
|
|
{
|
|
int id = window->fpsTypeList->GetCurrentPage()->GetId();
|
|
|
|
const char *type;
|
|
switch (id) {
|
|
case ID_FPSPANEL_COMMON: type = "Common"; break;
|
|
case ID_FPSPANEL_INTEGER: type = "Integer"; break;
|
|
case ID_FPSPANEL_FRACTION: type = "Fraction"; break;
|
|
case ID_FPSPANEL_NANOSECONDS: type = "Nanoseconds"; break;
|
|
}
|
|
|
|
config_set_string(GetGlobalConfig(), "Video", "FPSType", type);
|
|
SaveFPSCommon();
|
|
SaveFPSInteger();
|
|
SaveFPSFraction();
|
|
SaveFPSNanoseconds();
|
|
}
|
|
|
|
void BasicVideoData::SaveFPSCommon()
|
|
{
|
|
int sel = window->fpsCommonList->GetSelection();
|
|
wxString str = window->fpsCommonList->GetString(sel);
|
|
|
|
config_set_string(GetGlobalConfig(), "Video", "FPSCommon", str.c_str());
|
|
}
|
|
|
|
void BasicVideoData::SaveFPSInteger()
|
|
{
|
|
int val = window->fpsIntegerScroller->GetValue();
|
|
|
|
config_set_int(GetGlobalConfig(), "Video", "FPSInt", val);
|
|
}
|
|
|
|
void BasicVideoData::SaveFPSFraction()
|
|
{
|
|
int num = window->fpsNumeratorScroller->GetValue();
|
|
int den = window->fpsDenominatorScroller->GetValue();
|
|
|
|
config_set_int(GetGlobalConfig(), "Video", "FPSNum", num);
|
|
config_set_int(GetGlobalConfig(), "Video", "FPSDen", den);
|
|
}
|
|
|
|
void BasicVideoData::SaveFPSNanoseconds()
|
|
{
|
|
int val = window->fpsNanosecondsScroller->GetValue();
|
|
|
|
config_set_int(GetGlobalConfig(), "Video", "FPSNS", val);
|
|
}
|
|
|
|
void BasicVideoData::Apply()
|
|
{
|
|
uint32_t cx, cy;
|
|
|
|
if (!ConvertTextRes(window->baseResList, cx, cy)) {
|
|
config_set_uint(GetGlobalConfig(), "Video", "BaseCX", cx);
|
|
config_set_uint(GetGlobalConfig(), "Video", "BaseCY", cy);
|
|
}
|
|
|
|
if (ConvertTextRes(window->outputResList, cx, cy)) {
|
|
config_set_uint(GetGlobalConfig(), "Video", "OutputCX", cx);
|
|
config_set_uint(GetGlobalConfig(), "Video", "OutputCY", cy);
|
|
}
|
|
|
|
SaveOther();
|
|
SaveFPSData();
|
|
|
|
config_save(GetGlobalConfig());
|
|
|
|
/* TODO: If resolutiosn/fps were chaned, reset video */
|
|
|
|
SetSaved();
|
|
}
|
|
|
|
BasicSettingsData *CreateBasicVideoSettings(OBSBasicSettings *window)
|
|
{
|
|
return new BasicVideoData(window);
|
|
}
|