mirror of
https://github.com/RPCSX/rpcsx.git
synced 2025-12-06 07:12:14 +01:00
285 lines
9.3 KiB
C++
285 lines
9.3 KiB
C++
#include "stdafx.h"
|
|
#include "camera_settings_dialog.h"
|
|
#include "ui_camera_settings_dialog.h"
|
|
#include "permissions.h"
|
|
#include "Emu/Io/camera_config.h"
|
|
|
|
#include <QCameraDevice>
|
|
#include <QMediaDevices>
|
|
#include <QMessageBox>
|
|
#include <QPushButton>
|
|
|
|
LOG_CHANNEL(camera_log, "Camera");
|
|
|
|
template <>
|
|
void fmt_class_string<QVideoFrameFormat::PixelFormat>::format(std::string& out, u64 arg)
|
|
{
|
|
format_enum(out, arg, [](QVideoFrameFormat::PixelFormat value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case QVideoFrameFormat::Format_ARGB8888: return "ARGB8888";
|
|
case QVideoFrameFormat::Format_ARGB8888_Premultiplied: return "ARGB8888_Premultiplied";
|
|
case QVideoFrameFormat::Format_XRGB8888: return "XRGB8888";
|
|
case QVideoFrameFormat::Format_BGRA8888: return "BGRA8888";
|
|
case QVideoFrameFormat::Format_BGRA8888_Premultiplied: return "BGRA8888_Premultiplied";
|
|
case QVideoFrameFormat::Format_BGRX8888: return "BGRX8888";
|
|
case QVideoFrameFormat::Format_ABGR8888: return "ABGR8888";
|
|
case QVideoFrameFormat::Format_XBGR8888: return "XBGR8888";
|
|
case QVideoFrameFormat::Format_RGBA8888: return "RGBA8888";
|
|
case QVideoFrameFormat::Format_RGBX8888: return "RGBX8888";
|
|
case QVideoFrameFormat::Format_AYUV: return "AYUV";
|
|
case QVideoFrameFormat::Format_AYUV_Premultiplied: return "AYUV_Premultiplied";
|
|
case QVideoFrameFormat::Format_YUV420P: return "YUV420P";
|
|
case QVideoFrameFormat::Format_YUV422P: return "YUV422P";
|
|
case QVideoFrameFormat::Format_YV12: return "YV12";
|
|
case QVideoFrameFormat::Format_UYVY: return "UYVY";
|
|
case QVideoFrameFormat::Format_YUYV: return "YUYV";
|
|
case QVideoFrameFormat::Format_NV12: return "NV12";
|
|
case QVideoFrameFormat::Format_NV21: return "NV21";
|
|
case QVideoFrameFormat::Format_IMC1: return "IMC1";
|
|
case QVideoFrameFormat::Format_IMC2: return "IMC2";
|
|
case QVideoFrameFormat::Format_IMC3: return "IMC3";
|
|
case QVideoFrameFormat::Format_IMC4: return "IMC4";
|
|
case QVideoFrameFormat::Format_Y8: return "Y8";
|
|
case QVideoFrameFormat::Format_Y16: return "Y16";
|
|
case QVideoFrameFormat::Format_P010: return "P010";
|
|
case QVideoFrameFormat::Format_P016: return "P016";
|
|
case QVideoFrameFormat::Format_SamplerExternalOES: return "SamplerExternalOES";
|
|
case QVideoFrameFormat::Format_Jpeg: return "Jpeg";
|
|
case QVideoFrameFormat::Format_SamplerRect: return "SamplerRect";
|
|
default: return unknown;
|
|
}
|
|
});
|
|
}
|
|
|
|
Q_DECLARE_METATYPE(QCameraDevice);
|
|
|
|
camera_settings_dialog::camera_settings_dialog(QWidget* parent)
|
|
: QDialog(parent), ui(new Ui::camera_settings_dialog)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
load_config();
|
|
|
|
for (const QCameraDevice& camera_info : QMediaDevices::videoInputs())
|
|
{
|
|
if (camera_info.isNull())
|
|
continue;
|
|
ui->combo_camera->addItem(camera_info.description(), QVariant::fromValue(camera_info));
|
|
camera_log.notice("Found camera: '%s'", camera_info.description());
|
|
}
|
|
|
|
connect(ui->combo_camera, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &camera_settings_dialog::handle_camera_change);
|
|
connect(ui->combo_settings, QOverload<int>::of(&QComboBox::currentIndexChanged), this, &camera_settings_dialog::handle_settings_change);
|
|
connect(ui->buttonBox, &QDialogButtonBox::clicked, [this](QAbstractButton* button)
|
|
{
|
|
if (button == ui->buttonBox->button(QDialogButtonBox::Save))
|
|
{
|
|
save_config();
|
|
accept();
|
|
}
|
|
else if (button == ui->buttonBox->button(QDialogButtonBox::Apply))
|
|
{
|
|
save_config();
|
|
}
|
|
});
|
|
|
|
if (ui->combo_camera->count() == 0)
|
|
{
|
|
ui->combo_camera->setEnabled(false);
|
|
ui->combo_settings->setEnabled(false);
|
|
ui->buttonBox->button(QDialogButtonBox::Save)->setEnabled(false);
|
|
ui->buttonBox->button(QDialogButtonBox::Apply)->setEnabled(false);
|
|
}
|
|
else
|
|
{
|
|
// TODO: show camera ID somewhere
|
|
ui->combo_camera->setCurrentIndex(0);
|
|
}
|
|
}
|
|
|
|
camera_settings_dialog::~camera_settings_dialog()
|
|
{
|
|
}
|
|
|
|
void camera_settings_dialog::handle_camera_change(int index)
|
|
{
|
|
if (index < 0 || !ui->combo_camera->itemData(index).canConvert<QCameraDevice>())
|
|
{
|
|
ui->combo_settings->clear();
|
|
return;
|
|
}
|
|
|
|
const QCameraDevice camera_info = ui->combo_camera->itemData(index).value<QCameraDevice>();
|
|
|
|
if (camera_info.isNull())
|
|
{
|
|
ui->combo_settings->clear();
|
|
return;
|
|
}
|
|
|
|
m_camera.reset(new QCamera(camera_info));
|
|
m_media_capture_session.reset(new QMediaCaptureSession(nullptr));
|
|
m_media_capture_session->setCamera(m_camera.get());
|
|
m_media_capture_session->setVideoSink(ui->videoWidget->videoSink());
|
|
|
|
if (!m_camera->isAvailable())
|
|
{
|
|
ui->combo_settings->clear();
|
|
QMessageBox::warning(this, tr("Camera not available"), tr("The selected camera is not available.\nIt might be blocked by another application."));
|
|
return;
|
|
}
|
|
|
|
ui->combo_settings->blockSignals(true);
|
|
ui->combo_settings->clear();
|
|
|
|
QList<QCameraFormat> settings = camera_info.videoFormats();
|
|
std::sort(settings.begin(), settings.end(), [](const QCameraFormat& l, const QCameraFormat& r) -> bool
|
|
{
|
|
if (l.resolution().width() > r.resolution().width())
|
|
return true;
|
|
if (l.resolution().width() < r.resolution().width())
|
|
return false;
|
|
if (l.resolution().height() > r.resolution().height())
|
|
return true;
|
|
if (l.resolution().height() < r.resolution().height())
|
|
return false;
|
|
if (l.minFrameRate() > r.minFrameRate())
|
|
return true;
|
|
if (l.minFrameRate() < r.minFrameRate())
|
|
return false;
|
|
if (l.maxFrameRate() > r.maxFrameRate())
|
|
return true;
|
|
if (l.maxFrameRate() < r.maxFrameRate())
|
|
return false;
|
|
if (l.pixelFormat() > r.pixelFormat())
|
|
return true;
|
|
if (l.pixelFormat() < r.pixelFormat())
|
|
return false;
|
|
return false;
|
|
});
|
|
|
|
for (const QCameraFormat& setting : settings)
|
|
{
|
|
if (setting.isNull())
|
|
continue;
|
|
const QString description = tr("%0x%1, %2-%3 FPS, Format=%4")
|
|
.arg(setting.resolution().width())
|
|
.arg(setting.resolution().height())
|
|
.arg(setting.minFrameRate())
|
|
.arg(setting.maxFrameRate())
|
|
.arg(QString::fromStdString(fmt::format("%s", setting.pixelFormat())));
|
|
ui->combo_settings->addItem(description, QVariant::fromValue(setting));
|
|
}
|
|
ui->combo_settings->blockSignals(false);
|
|
|
|
if (ui->combo_settings->count() == 0)
|
|
{
|
|
ui->combo_settings->setEnabled(false);
|
|
}
|
|
else
|
|
{
|
|
// Load selected settings from config file
|
|
int index = 0;
|
|
bool success = false;
|
|
const std::string key = camera_info.id().toStdString();
|
|
cfg_camera::camera_setting cfg_setting = g_cfg_camera.get_camera_setting(key, success);
|
|
|
|
if (success)
|
|
{
|
|
camera_log.notice("Found config entry for camera \"%s\"", key);
|
|
|
|
// Select matching drowdown entry
|
|
const double epsilon = 0.001;
|
|
|
|
for (int i = 0; i < ui->combo_settings->count(); i++)
|
|
{
|
|
const QCameraFormat tmp = ui->combo_settings->itemData(i).value<QCameraFormat>();
|
|
|
|
if (tmp.resolution().width() == cfg_setting.width &&
|
|
tmp.resolution().height() == cfg_setting.height &&
|
|
tmp.minFrameRate() >= (cfg_setting.min_fps - epsilon) &&
|
|
tmp.minFrameRate() <= (cfg_setting.min_fps + epsilon) &&
|
|
tmp.maxFrameRate() >= (cfg_setting.max_fps - epsilon) &&
|
|
tmp.maxFrameRate() <= (cfg_setting.max_fps + epsilon) &&
|
|
tmp.pixelFormat() == static_cast<QVideoFrameFormat::PixelFormat>(cfg_setting.format))
|
|
{
|
|
index = i;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
|
|
ui->combo_settings->setCurrentIndex(std::max<int>(0, index));
|
|
ui->combo_settings->setEnabled(true);
|
|
|
|
// Update config to match user interface outcome
|
|
const QCameraFormat setting = ui->combo_settings->currentData().value<QCameraFormat>();
|
|
cfg_setting.width = setting.resolution().width();
|
|
cfg_setting.height = setting.resolution().height();
|
|
cfg_setting.min_fps = setting.minFrameRate();
|
|
cfg_setting.max_fps = setting.maxFrameRate();
|
|
cfg_setting.format = static_cast<int>(setting.pixelFormat());
|
|
g_cfg_camera.set_camera_setting(key, cfg_setting);
|
|
}
|
|
}
|
|
|
|
void camera_settings_dialog::handle_settings_change(int index)
|
|
{
|
|
if (!m_camera)
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (!m_camera->isAvailable())
|
|
{
|
|
QMessageBox::warning(this, tr("Camera not available"), tr("The selected camera is not available.\nIt might be blocked by another application."));
|
|
return;
|
|
}
|
|
|
|
if (!gui::utils::check_camera_permission(this, [this, index]()
|
|
{
|
|
handle_settings_change(index);
|
|
},
|
|
[this]()
|
|
{
|
|
QMessageBox::warning(this, tr("Camera permissions denied!"), tr("RPCS3 has no permissions to access cameras on this device."));
|
|
}))
|
|
{
|
|
return;
|
|
}
|
|
|
|
if (index >= 0 && ui->combo_settings->itemData(index).canConvert<QCameraFormat>() && ui->combo_camera->currentData().canConvert<QCameraDevice>())
|
|
{
|
|
const QCameraFormat setting = ui->combo_settings->itemData(index).value<QCameraFormat>();
|
|
if (!setting.isNull())
|
|
{
|
|
m_camera->setCameraFormat(setting);
|
|
}
|
|
|
|
cfg_camera::camera_setting cfg_setting;
|
|
cfg_setting.width = setting.resolution().width();
|
|
cfg_setting.height = setting.resolution().height();
|
|
cfg_setting.min_fps = setting.minFrameRate();
|
|
cfg_setting.max_fps = setting.maxFrameRate();
|
|
cfg_setting.format = static_cast<int>(setting.pixelFormat());
|
|
g_cfg_camera.set_camera_setting(ui->combo_camera->currentData().value<QCameraDevice>().id().toStdString(), cfg_setting);
|
|
}
|
|
|
|
m_camera->start();
|
|
}
|
|
|
|
void camera_settings_dialog::load_config()
|
|
{
|
|
if (!g_cfg_camera.load())
|
|
{
|
|
camera_log.notice("Could not load camera config. Using defaults.");
|
|
}
|
|
}
|
|
|
|
void camera_settings_dialog::save_config()
|
|
{
|
|
g_cfg_camera.save();
|
|
}
|