mirror of
https://github.com/RPCS3/rpcs3.git
synced 2025-02-06 00:40:11 +00:00
285 lines
10 KiB
C++
285 lines
10 KiB
C++
#include "stdafx.h"
|
|
#include "camera_settings_dialog.h"
|
|
#include "ui_camera_settings_dialog.h"
|
|
#include "Emu/Io/camera_config.h"
|
|
|
|
#include <QCameraInfo>
|
|
#include <QMessageBox>
|
|
#include <QPushButton>
|
|
|
|
LOG_CHANNEL(camera_log, "Camera");
|
|
|
|
template <>
|
|
void fmt_class_string<QVideoFrame::PixelFormat>::format(std::string& out, u64 arg)
|
|
{
|
|
format_enum(out, arg, [](QVideoFrame::PixelFormat value)
|
|
{
|
|
switch (value)
|
|
{
|
|
case QVideoFrame::Format_Invalid: return "Invalid";
|
|
case QVideoFrame::Format_ARGB32: return "ARGB32";
|
|
case QVideoFrame::Format_ARGB32_Premultiplied: return "ARGB32_Premultiplied";
|
|
case QVideoFrame::Format_RGB32: return "RGB32";
|
|
case QVideoFrame::Format_RGB24: return "RGB24";
|
|
case QVideoFrame::Format_RGB565: return "RGB565";
|
|
case QVideoFrame::Format_RGB555: return "RGB555";
|
|
case QVideoFrame::Format_ARGB8565_Premultiplied: return "ARGB8565_Premultiplied";
|
|
case QVideoFrame::Format_BGRA32: return "BGRA32";
|
|
case QVideoFrame::Format_BGRA32_Premultiplied: return "BGRA32_Premultiplied";
|
|
case QVideoFrame::Format_BGR32: return "BGR32";
|
|
case QVideoFrame::Format_BGR24: return "BGR24";
|
|
case QVideoFrame::Format_BGR565: return "BGR565";
|
|
case QVideoFrame::Format_BGR555: return "BGR555";
|
|
case QVideoFrame::Format_BGRA5658_Premultiplied: return "BGRA5658_Premultiplied";
|
|
case QVideoFrame::Format_AYUV444: return "AYUV444";
|
|
case QVideoFrame::Format_AYUV444_Premultiplied: return "AYUV444_Premultiplied";
|
|
case QVideoFrame::Format_YUV444: return "YUV444";
|
|
case QVideoFrame::Format_YUV420P: return "YUV420P";
|
|
case QVideoFrame::Format_YV12: return "YV12";
|
|
case QVideoFrame::Format_UYVY: return "UYVY";
|
|
case QVideoFrame::Format_YUYV: return "YUYV";
|
|
case QVideoFrame::Format_NV12: return "NV12";
|
|
case QVideoFrame::Format_NV21: return "NV21";
|
|
case QVideoFrame::Format_IMC1: return "IMC1";
|
|
case QVideoFrame::Format_IMC2: return "IMC2";
|
|
case QVideoFrame::Format_IMC3: return "IMC3";
|
|
case QVideoFrame::Format_IMC4: return "IMC4";
|
|
case QVideoFrame::Format_Y8: return "Y8";
|
|
case QVideoFrame::Format_Y16: return "Y16";
|
|
case QVideoFrame::Format_Jpeg: return "Jpeg";
|
|
case QVideoFrame::Format_CameraRaw: return "CameraRaw";
|
|
case QVideoFrame::Format_AdobeDng: return "AdobeDng";
|
|
case QVideoFrame::Format_ABGR32: return "ABGR32";
|
|
case QVideoFrame::Format_YUV422P: return "YUV422P";
|
|
case QVideoFrame::Format_User: return "User";
|
|
default: return unknown;
|
|
}
|
|
});
|
|
}
|
|
|
|
Q_DECLARE_METATYPE(QCameraInfo);
|
|
|
|
camera_settings_dialog::camera_settings_dialog(QWidget* parent)
|
|
: QDialog(parent)
|
|
, ui(new Ui::camera_settings_dialog)
|
|
{
|
|
ui->setupUi(this);
|
|
|
|
load_config();
|
|
|
|
for (const QCameraInfo& camera_info : QCameraInfo::availableCameras())
|
|
{
|
|
if (camera_info.isNull()) continue;
|
|
ui->combo_camera->addItem(camera_info.description(), QVariant::fromValue(camera_info));
|
|
}
|
|
|
|
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<QCameraInfo>())
|
|
{
|
|
ui->combo_settings->clear();
|
|
return;
|
|
}
|
|
|
|
const QCameraInfo camera_info = ui->combo_camera->itemData(index).value<QCameraInfo>();
|
|
|
|
if (camera_info.isNull())
|
|
{
|
|
ui->combo_settings->clear();
|
|
return;
|
|
}
|
|
|
|
m_camera.reset(new QCamera(camera_info));
|
|
m_camera->setViewfinder(ui->viewfinder);
|
|
|
|
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;
|
|
}
|
|
|
|
m_camera->load();
|
|
|
|
ui->combo_settings->blockSignals(true);
|
|
ui->combo_settings->clear();
|
|
|
|
QList<QCameraViewfinderSettings> settings = m_camera->supportedViewfinderSettings();
|
|
std::sort(settings.begin(), settings.end(), [](const QCameraViewfinderSettings& l, const QCameraViewfinderSettings& 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.minimumFrameRate() > r.minimumFrameRate()) return true;
|
|
if (l.minimumFrameRate() < r.minimumFrameRate()) return false;
|
|
if (l.maximumFrameRate() > r.maximumFrameRate()) return true;
|
|
if (l.maximumFrameRate() < r.maximumFrameRate()) return false;
|
|
if (l.pixelFormat() > r.pixelFormat()) return true;
|
|
if (l.pixelFormat() < r.pixelFormat()) return false;
|
|
if (l.pixelAspectRatio().width() > r.pixelAspectRatio().width()) return true;
|
|
if (l.pixelAspectRatio().width() < r.pixelAspectRatio().width()) return false;
|
|
if (l.pixelAspectRatio().height() > r.pixelAspectRatio().height()) return true;
|
|
if (l.pixelAspectRatio().height() < r.pixelAspectRatio().height()) return false;
|
|
return false;
|
|
});
|
|
|
|
for (const QCameraViewfinderSettings& setting : settings)
|
|
{
|
|
if (setting.isNull()) continue;
|
|
const QString description = tr("%0x%1, %2-%3 FPS, Format=%4, PixelAspectRatio=%5x%6")
|
|
.arg(setting.resolution().width())
|
|
.arg(setting.resolution().height())
|
|
.arg(setting.minimumFrameRate())
|
|
.arg(setting.maximumFrameRate())
|
|
.arg(QString::fromStdString(fmt::format("%s", setting.pixelFormat())))
|
|
.arg(setting.pixelAspectRatio().width())
|
|
.arg(setting.pixelAspectRatio().height());
|
|
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.deviceName().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);
|
|
|
|
// Convert to Qt data
|
|
QCameraViewfinderSettings setting;
|
|
setting.setResolution(cfg_setting.width, cfg_setting.height);
|
|
setting.setMinimumFrameRate(cfg_setting.min_fps);
|
|
setting.setMaximumFrameRate(cfg_setting.max_fps);
|
|
setting.setPixelFormat(static_cast<QVideoFrame::PixelFormat>(cfg_setting.format));
|
|
setting.setPixelAspectRatio(cfg_setting.pixel_aspect_width, cfg_setting.pixel_aspect_height);
|
|
|
|
// Select matching drowdown entry
|
|
const double epsilon = 0.001;
|
|
|
|
for (int i = 0; i < ui->combo_settings->count(); i++)
|
|
{
|
|
const QCameraViewfinderSettings tmp = ui->combo_settings->itemData(i).value<QCameraViewfinderSettings>();
|
|
|
|
if (tmp.resolution().width() == setting.resolution().width() &&
|
|
tmp.resolution().height() == setting.resolution().height() &&
|
|
tmp.minimumFrameRate() >= (setting.minimumFrameRate() - epsilon) &&
|
|
tmp.minimumFrameRate() <= (setting.minimumFrameRate() + epsilon) &&
|
|
tmp.maximumFrameRate() >= (setting.maximumFrameRate() - epsilon) &&
|
|
tmp.maximumFrameRate() <= (setting.maximumFrameRate() + epsilon) &&
|
|
tmp.pixelFormat() == setting.pixelFormat() &&
|
|
tmp.pixelAspectRatio().width() == setting.pixelAspectRatio().width() &&
|
|
tmp.pixelAspectRatio().height() == setting.pixelAspectRatio().height())
|
|
{
|
|
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 QCameraViewfinderSettings setting = ui->combo_settings->currentData().value<QCameraViewfinderSettings>();
|
|
cfg_setting.width = setting.resolution().width();
|
|
cfg_setting.height = setting.resolution().height();
|
|
cfg_setting.min_fps = setting.minimumFrameRate();
|
|
cfg_setting.max_fps = setting.maximumFrameRate();
|
|
cfg_setting.format = static_cast<int>(setting.pixelFormat());
|
|
cfg_setting.pixel_aspect_width = setting.pixelAspectRatio().width();
|
|
cfg_setting.pixel_aspect_height = setting.pixelAspectRatio().height();
|
|
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 (index >= 0 && ui->combo_settings->itemData(index).canConvert<QCameraViewfinderSettings>() && ui->combo_camera->currentData().canConvert<QCameraInfo>())
|
|
{
|
|
const QCameraViewfinderSettings setting = ui->combo_settings->itemData(index).value<QCameraViewfinderSettings>();
|
|
if (!setting.isNull())
|
|
{
|
|
m_camera->setViewfinderSettings(setting);
|
|
}
|
|
|
|
cfg_camera::camera_setting cfg_setting;
|
|
cfg_setting.width = setting.resolution().width();
|
|
cfg_setting.height = setting.resolution().height();
|
|
cfg_setting.min_fps = setting.minimumFrameRate();
|
|
cfg_setting.max_fps = setting.maximumFrameRate();
|
|
cfg_setting.format = static_cast<int>(setting.pixelFormat());
|
|
cfg_setting.pixel_aspect_width = setting.pixelAspectRatio().width();
|
|
cfg_setting.pixel_aspect_height = setting.pixelAspectRatio().height();
|
|
g_cfg_camera.set_camera_setting(ui->combo_camera->currentData().value<QCameraInfo>().deviceName().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();
|
|
}
|