obs-studio/UI/window-basic-stats.cpp

502 lines
13 KiB
C++

#include "obs-frontend-api/obs-frontend-api.h"
#include "window-basic-stats.hpp"
#include "window-basic-main.hpp"
#include "platform.hpp"
#include "obs-app.hpp"
#include <QDesktopWidget>
#include <QPushButton>
#include <QScrollArea>
#include <QVBoxLayout>
#include <QHBoxLayout>
#include <QGridLayout>
#include <string>
#define TIMER_INTERVAL 2000
static void setThemeID(QWidget *widget, const QString &themeID)
{
if (widget->property("themeID").toString() != themeID) {
widget->setProperty("themeID", themeID);
/* force style sheet recalculation */
QString qss = widget->styleSheet();
widget->setStyleSheet("/* */");
widget->setStyleSheet(qss);
}
}
OBSBasicStats::OBSBasicStats(QWidget *parent)
: QWidget (parent),
cpu_info (os_cpu_usage_info_start()),
timer (this)
{
QVBoxLayout *mainLayout = new QVBoxLayout();
QGridLayout *topLayout = new QGridLayout();
outputLayout = new QGridLayout();
int row = 0;
auto newStatBare = [&] (QString name, QWidget *label, int col)
{
QLabel *typeLabel = new QLabel(name, this);
topLayout->addWidget(typeLabel, row, col);
topLayout->addWidget(label, row++, col + 1);
};
auto newStat = [&] (const char *strLoc, QWidget *label, int col)
{
std::string str = "Basic.Stats.";
str += strLoc;
newStatBare(QTStr(str.c_str()), label, col);
};
/* --------------------------------------------- */
cpuUsage = new QLabel(this);
hddSpace = new QLabel(this);
memUsage = new QLabel(this);
newStat("CPUUsage", cpuUsage, 0);
newStat("HDDSpaceAvailable", hddSpace, 0);
newStat("MemoryUsage", memUsage, 0);
fps = new QLabel(this);
renderTime = new QLabel(this);
skippedFrames = new QLabel(this);
missedFrames = new QLabel(this);
row = 0;
newStatBare("FPS", fps, 2);
newStat("AverageTimeToRender", renderTime, 2);
newStat("MissedFrames", missedFrames, 2);
newStat("SkippedFrames", skippedFrames, 2);
/* --------------------------------------------- */
QPushButton *closeButton = new QPushButton(QTStr("Close"));
QPushButton *resetButton = new QPushButton(QTStr("Reset"));
QHBoxLayout *buttonLayout = new QHBoxLayout;
buttonLayout->addStretch();
buttonLayout->addWidget(resetButton);
buttonLayout->addWidget(closeButton);
/* --------------------------------------------- */
int col = 0;
auto addOutputCol = [&] (const char *loc)
{
QLabel *label = new QLabel(QTStr(loc), this);
label->setStyleSheet("font-weight: bold");
outputLayout->addWidget(label, 0, col++);
};
addOutputCol("Basic.Settings.Output");
addOutputCol("Basic.Stats.Status");
addOutputCol("Basic.Stats.DroppedFrames");
addOutputCol("Basic.Stats.MegabytesSent");
addOutputCol("Basic.Stats.Bitrate");
/* --------------------------------------------- */
AddOutputLabels(QTStr("Basic.Stats.Output.Stream"));
AddOutputLabels(QTStr("Basic.Stats.Output.Recording"));
/* --------------------------------------------- */
QVBoxLayout *outputContainerLayout = new QVBoxLayout();
outputContainerLayout->addLayout(outputLayout);
outputContainerLayout->addStretch();
QWidget *widget = new QWidget(this);
widget->setLayout(outputContainerLayout);
QScrollArea *scrollArea = new QScrollArea(this);
scrollArea->setWidget(widget);
scrollArea->setWidgetResizable(true);
/* --------------------------------------------- */
mainLayout->addLayout(topLayout);
mainLayout->addWidget(scrollArea);
mainLayout->addLayout(buttonLayout);
setLayout(mainLayout);
/* --------------------------------------------- */
connect(closeButton, &QPushButton::clicked, [this] () {close();});
connect(resetButton, &QPushButton::clicked, [this] () {Reset();});
installEventFilter(CreateShortcutFilter());
resize(800, 280);
setWindowFlags(Qt::Window |
Qt::WindowMinimizeButtonHint |
Qt::WindowCloseButtonHint);
setWindowTitle(QTStr("Basic.Stats"));
setWindowModality(Qt::NonModal);
setAttribute(Qt::WA_DeleteOnClose, true);
QObject::connect(&timer, &QTimer::timeout, this, &OBSBasicStats::Update);
timer.setInterval(TIMER_INTERVAL);
timer.start();
Update();
OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
const char *geometry = config_get_string(main->Config(),
"Stats", "geometry");
if (geometry != NULL) {
QByteArray byteArray = QByteArray::fromBase64(
QByteArray(geometry));
restoreGeometry(byteArray);
QRect windowGeometry = normalGeometry();
if (!WindowPositionValid(windowGeometry)) {
QRect rect = App()->desktop()->geometry();
setGeometry(QStyle::alignedRect(
Qt::LeftToRight,
Qt::AlignCenter,
size(), rect));
}
}
}
void OBSBasicStats::closeEvent(QCloseEvent *event)
{
OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
if (isVisible()) {
config_set_string(main->Config(),
"Stats", "geometry",
saveGeometry().toBase64().constData());
config_save_safe(main->Config(), "tmp", nullptr);
}
QWidget::closeEvent(event);
}
OBSBasicStats::~OBSBasicStats()
{
os_cpu_usage_info_destroy(cpu_info);
}
void OBSBasicStats::AddOutputLabels(QString name)
{
OutputLabels ol;
ol.name = new QLabel(name, this);
ol.status = new QLabel(this);
ol.droppedFrames = new QLabel(this);
ol.megabytesSent = new QLabel(this);
ol.bitrate = new QLabel(this);
int newPointSize = ol.status->font().pointSize();
newPointSize *= 13;
newPointSize /= 10;
QString qss =
QString("font-size: %1pt").arg(QString::number(newPointSize));
ol.status->setStyleSheet(qss);
int col = 0;
int row = outputLabels.size() + 1;
outputLayout->addWidget(ol.name, row, col++);
outputLayout->addWidget(ol.status, row, col++);
outputLayout->addWidget(ol.droppedFrames, row, col++);
outputLayout->addWidget(ol.megabytesSent, row, col++);
outputLayout->addWidget(ol.bitrate, row, col++);
outputLabels.push_back(ol);
}
static uint32_t first_encoded = 0xFFFFFFFF;
static uint32_t first_skipped = 0xFFFFFFFF;
static uint32_t first_rendered = 0xFFFFFFFF;
static uint32_t first_lagged = 0xFFFFFFFF;
void OBSBasicStats::InitializeValues()
{
video_t *video = obs_get_video();
first_encoded = video_output_get_total_frames(video);
first_skipped = video_output_get_skipped_frames(video);
first_rendered = obs_get_total_frames();
first_lagged = obs_get_lagged_frames();
}
void OBSBasicStats::Update()
{
OBSBasic *main = reinterpret_cast<OBSBasic*>(App()->GetMainWindow());
/* TODO: Un-hardcode */
struct obs_video_info ovi = {};
obs_get_video_info(&ovi);
OBSOutput strOutput = obs_frontend_get_streaming_output();
OBSOutput recOutput = obs_frontend_get_recording_output();
obs_output_release(strOutput);
obs_output_release(recOutput);
if (!strOutput && !recOutput)
return;
/* ------------------------------------------- */
/* general usage */
double curFPS = obs_get_active_fps();
double obsFPS = (double)ovi.fps_num / (double)ovi.fps_den;
QString str = QString::number(curFPS, 'f', 2);
fps->setText(str);
if (curFPS < (obsFPS * 0.8))
setThemeID(fps, "error");
else if (curFPS < (obsFPS * 0.95))
setThemeID(fps, "warning");
else
setThemeID(fps, "");
/* ------------------ */
double usage = os_cpu_usage_info_query(cpu_info);
str = QString::number(usage, 'g', 2) + QStringLiteral("%");
cpuUsage->setText(str);
/* ------------------ */
const char *mode = config_get_string(main->Config(), "Output", "Mode");
const char *path = strcmp(mode, "Advanced") ?
config_get_string(main->Config(), "SimpleOutput", "FilePath") :
config_get_string(main->Config(), "AdvOut", "RecFilePath");
#define MBYTE (1024ULL * 1024ULL)
#define GBYTE (1024ULL * 1024ULL * 1024ULL)
#define TBYTE (1024ULL * 1024ULL * 1024ULL * 1024ULL)
uint64_t num_bytes = os_get_free_disk_space(path);
QString abrv = QStringLiteral(" MB");
long double num;
num = (long double)num_bytes / (1024.0l * 1024.0l);
if (num_bytes > TBYTE) {
num /= 1024.0l * 1024.0l;
abrv = QStringLiteral(" TB");
} else if (num_bytes > GBYTE) {
num /= 1024.0l;
abrv = QStringLiteral(" GB");
}
str = QString::number(num, 'f', 1) + abrv;
hddSpace->setText(str);
if (num_bytes < GBYTE)
setThemeID(hddSpace, "error");
else if (num_bytes < (5 * GBYTE))
setThemeID(hddSpace, "warning");
else
setThemeID(hddSpace, "");
/* ------------------ */
num = (long double)os_get_proc_resident_size() / (1024.0l * 1024.0l);
str = QString::number(num, 'f', 1) + QStringLiteral(" MB");
memUsage->setText(str);
/* ------------------ */
num = (long double)obs_get_average_frame_time_ns() / 1000000.0l;
str = QString::number(num, 'f', 1) + QStringLiteral(" ms");
renderTime->setText(str);
long double fpsFrameTime =
(long double)ovi.fps_den * 1000.0l / (long double)ovi.fps_num;
if (num > fpsFrameTime)
setThemeID(renderTime, "error");
else if (num > fpsFrameTime * 0.75l)
setThemeID(renderTime, "warning");
else
setThemeID(renderTime, "");
/* ------------------ */
video_t *video = obs_get_video();
uint32_t total_encoded = video_output_get_total_frames(video);
uint32_t total_skipped = video_output_get_skipped_frames(video);
if (total_encoded < first_encoded || total_skipped < first_skipped) {
first_encoded = total_encoded;
first_skipped = total_skipped;
}
total_encoded -= first_encoded;
total_skipped -= first_skipped;
num = total_encoded
? (long double)total_skipped / (long double)total_encoded
: 0.0l;
num *= 100.0l;
str = QString("%1 / %2 (%3%)").arg(
QString::number(total_skipped),
QString::number(total_encoded),
QString::number(num, 'f', 1));
skippedFrames->setText(str);
if (num > 5.0l)
setThemeID(skippedFrames, "error");
else if (num > 1.0l)
setThemeID(skippedFrames, "warning");
else
setThemeID(skippedFrames, "");
/* ------------------ */
uint32_t total_rendered = obs_get_total_frames();
uint32_t total_lagged = obs_get_lagged_frames();
if (total_rendered < first_rendered || total_lagged < first_lagged) {
first_rendered = total_rendered;
first_lagged = total_lagged;
}
total_rendered -= first_rendered;
total_lagged -= first_lagged;
num = total_rendered
? (long double)total_lagged / (long double)total_rendered
: 0.0l;
num *= 100.0l;
str = QString("%1 / %2 (%3%)").arg(
QString::number(total_lagged),
QString::number(total_rendered),
QString::number(num, 'f', 1));
missedFrames->setText(str);
if (num > 5.0l)
setThemeID(missedFrames, "error");
else if (num > 1.0l)
setThemeID(missedFrames, "warning");
else
setThemeID(missedFrames, "");
/* ------------------------------------------- */
/* recording/streaming stats */
outputLabels[0].Update(strOutput, false);
outputLabels[1].Update(recOutput, true);
}
void OBSBasicStats::Reset()
{
timer.start();
first_encoded = 0xFFFFFFFF;
first_skipped = 0xFFFFFFFF;
first_rendered = 0xFFFFFFFF;
first_lagged = 0xFFFFFFFF;
OBSOutput strOutput = obs_frontend_get_streaming_output();
OBSOutput recOutput = obs_frontend_get_recording_output();
obs_output_release(strOutput);
obs_output_release(recOutput);
outputLabels[0].Reset(strOutput);
outputLabels[1].Reset(recOutput);
Update();
}
void OBSBasicStats::OutputLabels::Update(obs_output_t *output, bool rec)
{
uint64_t totalBytes = output ? obs_output_get_total_bytes(output) : 0;
uint64_t curTime = os_gettime_ns();
uint64_t bytesSent = totalBytes;
if (bytesSent < lastBytesSent)
bytesSent = 0;
if (bytesSent == 0)
lastBytesSent = 0;
uint64_t bitsBetween = (bytesSent - lastBytesSent) * 8;
long double timePassed = (long double)(curTime - lastBytesSentTime) /
1000000000.0l;
long double kbps = (long double)bitsBetween /
timePassed / 1000.0l;
if (timePassed < 0.01l)
kbps = 0.0l;
QString str = QTStr("Basic.Stats.Status.Inactive");
QString themeID;
bool active = output ? obs_output_active(output) : false;
if (rec) {
if (active)
str = QTStr("Basic.Stats.Status.Recording");
} else {
if (active) {
bool reconnecting = output
? obs_output_reconnecting(output)
: false;
if (reconnecting) {
str = QTStr("Basic.Stats.Status.Reconnecting");
themeID = "error";
} else {
str = QTStr("Basic.Stats.Status.Live");
themeID = "good";
}
}
}
status->setText(str);
setThemeID(status, themeID);
long double num = (long double)totalBytes / (1024.0l * 1024.0l);
megabytesSent->setText(
QString("%1 MB").arg(QString::number(num, 'f', 1)));
bitrate->setText(
QString("%1 kb/s").arg(QString::number(kbps, 'f', 0)));
if (!rec) {
int total = output ? obs_output_get_total_frames(output) : 0;
int dropped = output ? obs_output_get_frames_dropped(output) : 0;
if (total < first_total || dropped < first_dropped) {
first_total = 0;
first_dropped = 0;
}
total -= first_total;
dropped -= first_dropped;
num = total
? (long double)dropped / (long double)total * 100.0l
: 0.0l;
str = QString("%1 / %2 (%3%)").arg(
QString::number(dropped),
QString::number(total),
QString::number(num, 'f', 1));
droppedFrames->setText(str);
if (num > 5.0l)
setThemeID(droppedFrames, "error");
else if (num > 1.0l)
setThemeID(droppedFrames, "warning");
else
setThemeID(droppedFrames, "");
}
lastBytesSent = bytesSent;
lastBytesSentTime = curTime;
}
void OBSBasicStats::OutputLabels::Reset(obs_output_t *output)
{
if (!output)
return;
first_total = obs_output_get_total_frames(output);
first_dropped = obs_output_get_frames_dropped(output);
}