piwalker/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2024-11-14 21:37:52 -07:00
Code Issues Actions Packages Projects Releases Wiki Activity

Video: split frame dumping settings into 3 resolution dumping modes

Browse Source 
also polish aspect ratio related code for clarity
This commit is contained in:
Filoppi 2024-02-22 02:11:31 +02:00
parent 1f34adf216
commit 72db62e178
8 changed files with 90 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
Source/Core/Core/Config/GraphicsSettings.cpp
View File

@ -70,8 +70,9 @@ const Info<std::string> GFX_DUMP_PIXEL_FORMAT{{System::GFX, "Settings", "DumpPix
const Info<std::string> GFX_DUMP_ENCODER{{System::GFX, "Settings", "DumpEncoder"}, ""};
const Info<std::string> GFX_DUMP_PATH{{System::GFX, "Settings", "DumpPath"}, ""};
const Info<int> GFX_BITRATE_KBPS{{System::GFX, "Settings", "BitrateKbps"}, 25000};
const Info<bool> GFX_INTERNAL_RESOLUTION_FRAME_DUMPS{
{System::GFX, "Settings", "InternalResolutionFrameDumps"}, false};
const Info<FrameDumpResolutionType> GFX_FRAME_DUMPS_RESOLUTION_TYPE{
{System::GFX, "Settings", "FrameDumpsResolutionType"},
FrameDumpResolutionType::XFB_ASPECT_RATIO_CORRECTED_RESOLUTION};
const Info<int> GFX_PNG_COMPRESSION_LEVEL{{System::GFX, "Settings", "PNGCompressionLevel"}, 6};
const Info<bool> GFX_ENABLE_GPU_TEXTURE_DECODING{
{System::GFX, "Settings", "EnableGPUTextureDecoding"}, false};

3
Source/Core/Core/Config/GraphicsSettings.h
View File

@ -14,6 +14,7 @@ enum class TextureFilteringMode : int;
enum class OutputResamplingMode : int;
enum class ColorCorrectionRegion : int;
enum class TriState : int;
enum class FrameDumpResolutionType : int;
namespace Config
{
@ -67,7 +68,7 @@ extern const Info<std::string> GFX_DUMP_PIXEL_FORMAT;
extern const Info<std::string> GFX_DUMP_ENCODER;
extern const Info<std::string> GFX_DUMP_PATH;
extern const Info<int> GFX_BITRATE_KBPS;
extern const Info<bool> GFX_INTERNAL_RESOLUTION_FRAME_DUMPS;
extern const Info<FrameDumpResolutionType> GFX_FRAME_DUMPS_RESOLUTION_TYPE;
extern const Info<int> GFX_PNG_COMPRESSION_LEVEL;
extern const Info<bool> GFX_ENABLE_GPU_TEXTURE_DECODING;
extern const Info<bool> GFX_ENABLE_PIXEL_LIGHTING;

40
Source/Core/DolphinQt/Config/Graphics/AdvancedWidget.cpp
View File

@ -135,21 +135,24 @@ void AdvancedWidget::CreateWidgets()
auto* dump_layout = new QGridLayout();
dump_box->setLayout(dump_layout);
m_use_fullres_framedumps = new ConfigBool(tr("Dump at Internal Resolution"),
Config::GFX_INTERNAL_RESOLUTION_FRAME_DUMPS);
m_frame_dumps_resolution_type =
new ConfigChoice({tr("Window Resolution"), tr("Aspect Ratio Corrected Internal Resolution"),
tr("Raw Internal Resolution")},
Config::GFX_FRAME_DUMPS_RESOLUTION_TYPE);
m_dump_use_ffv1 = new ConfigBool(tr("Use Lossless Codec (FFV1)"), Config::GFX_USE_FFV1);
m_dump_bitrate = new ConfigInteger(0, 1000000, Config::GFX_BITRATE_KBPS, 1000);
m_png_compression_level = new ConfigInteger(0, 9, Config::GFX_PNG_COMPRESSION_LEVEL);
dump_layout->addWidget(m_use_fullres_framedumps, 0, 0);
dump_layout->addWidget(new QLabel(tr("Resolution Type:")), 0, 0);
dump_layout->addWidget(m_frame_dumps_resolution_type, 0, 1);
#if defined(HAVE_FFMPEG)
dump_layout->addWidget(m_dump_use_ffv1, 0, 1);
dump_layout->addWidget(new QLabel(tr("Bitrate (kbps):")), 1, 0);
dump_layout->addWidget(m_dump_bitrate, 1, 1);
dump_layout->addWidget(m_dump_use_ffv1, 1, 0);
dump_layout->addWidget(new QLabel(tr("Bitrate (kbps):")), 2, 0);
dump_layout->addWidget(m_dump_bitrate, 2, 1);
#endif
dump_layout->addWidget(new QLabel(tr("PNG Compression Level:")), 2, 0);
dump_layout->addWidget(new QLabel(tr("PNG Compression Level:")), 3, 0);
m_png_compression_level->SetTitle(tr("PNG Compression Level"));
dump_layout->addWidget(m_png_compression_level, 2, 1);
dump_layout->addWidget(m_png_compression_level, 3, 1);
// Misc.
auto* misc_box = new QGroupBox(tr("Misc"));
@ -338,10 +341,21 @@ void AdvancedWidget::AddDescriptions()
static const char TR_LOAD_GRAPHICS_MODS_DESCRIPTION[] =
QT_TR_NOOP("Loads graphics mods from User/Load/GraphicsMods/.<br><br><dolphin_emphasis>If "
"unsure, leave this unchecked.</dolphin_emphasis>");
static const char TR_INTERNAL_RESOLUTION_FRAME_DUMPING_DESCRIPTION[] = QT_TR_NOOP(
"Creates frame dumps and screenshots at the raw internal resolution of the renderer,"
"rather than using the size it is displayed within the window.<br><br>"
"<dolphin_emphasis>If unsure, leave this unchecked.</dolphin_emphasis>");
static const char TR_FRAME_DUMPS_RESOLUTION_TYPE_DESCRIPTION[] = QT_TR_NOOP(
"Selects how frame dumps (videos) and screenshots are going to be captured.<br>If the game "
"or window resolution change during a recording, multiple video files might be created.<br>"
"Note that color correction and cropping are always ignored by the captures."
"<br><br><b>Window Resolution</b>: Uses the output window resolution (without black bars)."
"<br>This is a simple dumping option that will capture the image more or less as you see it."
"<br><b>Aspect Ratio Corrected Internal Resolution</b>: "
"Uses the Internal Resolution (XFB size), and corrects it by the target aspect ratio.<br>"
"This option will consistently dump at the specified Internal Resolution "
"regardless of how the image is displayed during recording."
"<br><b>Raw Internal Resolution</b>: Uses the Internal Resolution (XFB size) "
"without correcting it with the target aspect ratio.<br>"
"This will provide a clean dump without any aspect ratio correction so users have as raw as "
"possible input for external editing software.<br><br><dolphin_emphasis>If unsure, leave "
"this at \"Aspect Ratio Corrected Internal Resolution\".</dolphin_emphasis>");
#if defined(HAVE_FFMPEG)
static const char TR_USE_FFV1_DESCRIPTION[] =
QT_TR_NOOP("Encodes frame dumps using the FFV1 codec.<br><br><dolphin_emphasis>If "
@ -432,7 +446,7 @@ void AdvancedWidget::AddDescriptions()
m_dump_xfb_target->SetDescription(tr(TR_DUMP_XFB_DESCRIPTION));
m_disable_vram_copies->SetDescription(tr(TR_DISABLE_VRAM_COPIES_DESCRIPTION));
m_enable_graphics_mods->SetDescription(tr(TR_LOAD_GRAPHICS_MODS_DESCRIPTION));
m_use_fullres_framedumps->SetDescription(tr(TR_INTERNAL_RESOLUTION_FRAME_DUMPING_DESCRIPTION));
m_frame_dumps_resolution_type->SetDescription(tr(TR_FRAME_DUMPS_RESOLUTION_TYPE_DESCRIPTION));
#ifdef HAVE_FFMPEG
m_dump_use_ffv1->SetDescription(tr(TR_USE_FFV1_DESCRIPTION));
#endif

2
Source/Core/DolphinQt/Config/Graphics/AdvancedWidget.h
View File

@ -60,7 +60,7 @@ private:
// Frame dumping
ConfigBool* m_dump_use_ffv1;
ConfigBool* m_use_fullres_framedumps;
ConfigChoice* m_frame_dumps_resolution_type;
ConfigInteger* m_dump_bitrate;
ConfigInteger* m_png_compression_level;

51
Source/Core/VideoCommon/Present.cpp
View File

@ -212,23 +212,49 @@ void Presenter::ProcessFrameDumping(u64 ticks) const
if (g_frame_dumper->IsFrameDumping() && m_xfb_entry)
{
MathUtil::Rectangle<int> target_rect;
if (!g_ActiveConfig.bInternalResolutionFrameDumps && !g_gfx->IsHeadless())
target_rect = GetTargetRectangle();
else
switch (g_ActiveConfig.frame_dumps_resolution_type)
{
default:
case FrameDumpResolutionType::WINDOW_RESOLUTION:
{
if (!g_gfx->IsHeadless())
{
target_rect = GetTargetRectangle();
break;
}
[[fallthrough]];
}
case FrameDumpResolutionType::XFB_ASPECT_RATIO_CORRECTED_RESOLUTION:
{
target_rect = m_xfb_rect;
const bool allow_stretch = false;
auto [float_width, float_height] =
ScaleToDisplayAspectRatio(m_xfb_rect.GetWidth(), m_xfb_rect.GetHeight(), allow_stretch);
const float draw_aspect_ratio = CalculateDrawAspectRatio(allow_stretch);
auto [int_width, int_height] =
FindClosestIntegerResolution(float_width, float_height, draw_aspect_ratio);
target_rect = MathUtil::Rectangle<int>(0, 0, int_width, int_height);
break;
}
case FrameDumpResolutionType::XFB_RAW_RESOLUTION:
{
target_rect = m_xfb_rect;
break;
}
}
int width = target_rect.GetWidth();
int height = target_rect.GetHeight();
// Ensure divisibility by "VIDEO_ENCODER_LCM" to make it compatible with all the video
// encoders. Note that this is theoretically only necessary when recording videos and not
// Ensure divisibility by "VIDEO_ENCODER_LCM" and a min of 1 to make it compatible with all the
// video encoders. Note that this is theoretically only necessary when recording videos and not
// screenshots.
// We always scale positively to make sure the least amount of information is lost.
//
// TODO: this should be added as black padding on the edges by the frame dumper.
if ((width % VIDEO_ENCODER_LCM) != 0)
if ((width % VIDEO_ENCODER_LCM) != 0 || width == 0)
width += VIDEO_ENCODER_LCM - (width % VIDEO_ENCODER_LCM);
if ((height % VIDEO_ENCODER_LCM) != 0)
if ((height % VIDEO_ENCODER_LCM) != 0 || height == 0)
height += VIDEO_ENCODER_LCM - (height % VIDEO_ENCODER_LCM);
// Remove any black borders, there would be no point in including them in the recording
@ -237,6 +263,8 @@ void Presenter::ProcessFrameDumping(u64 ticks) const
target_rect.right = width;
target_rect.bottom = height;
// TODO: any scaling done by this won't be gamma corrected,
// we should either apply post processing as well, or port its gamma correction code
g_frame_dumper->DumpCurrentFrame(m_xfb_entry->texture.get(), m_xfb_rect, target_rect, ticks,
m_frame_count);
}
@ -360,7 +388,8 @@ float Presenter::CalculateDrawAspectRatio(bool allow_stretch) const
if (aspect_mode == AspectMode::Stretch)
return (static_cast<float>(m_backbuffer_width) / static_cast<float>(m_backbuffer_height));
auto& vi = Core::System::GetInstance().GetVideoInterface();
// The actual aspect ratio of the XFB texture is irrelevant, the VI one is the one that matters
const auto& vi = Core::System::GetInstance().GetVideoInterface();
const float source_aspect_ratio = vi.GetAspectRatio();
// This will scale up the source ~4:3 resolution to its equivalent ~16:9 resolution
@ -551,7 +580,7 @@ void Presenter::UpdateDrawRectangle()
// Don't know if there is a better place for this code so there isn't a 1 frame delay
if (g_ActiveConfig.bWidescreenHack)
{
auto& vi = Core::System::GetInstance().GetVideoInterface();
const auto& vi = Core::System::GetInstance().GetVideoInterface();
float source_aspect_ratio = vi.GetAspectRatio();
// If the game is meant to be in widescreen (or forced to),
// scale the source aspect ratio to it.
@ -595,9 +624,10 @@ void Presenter::UpdateDrawRectangle()
// Crop the picture to a standard aspect ratio. (if enabled)
auto [crop_width, crop_height] = ApplyStandardAspectCrop(draw_width, draw_height);
const float crop_aspect_ratio = crop_width / crop_height;
// scale the picture to fit the rendering window
if (win_aspect_ratio >= crop_width / crop_height)
if (win_aspect_ratio >= crop_aspect_ratio)
{
// the window is flatter than the picture
draw_width *= win_height / crop_height;
@ -668,6 +698,7 @@ std::tuple<float, float> Presenter::ScaleToDisplayAspectRatio(const int width, c
std::tuple<int, int> Presenter::CalculateOutputDimensions(int width, int height,
bool allow_stretch) const
{
// Protect against zero width and height, a minimum of 1 will do
width = std::max(width, 1);
height = std::max(height, 1);

3
Source/Core/VideoCommon/Present.h
View File

@ -107,10 +107,13 @@ private:
void OnBackBufferSizeChanged();
// Scales a raw XFB resolution to the target (display) aspect ratio,
// also accounting for crop and other minor adjustments
std::tuple<int, int> CalculateOutputDimensions(int width, int height,
bool allow_stretch = true) const;
std::tuple<float, float> ApplyStandardAspectCrop(float width, float height,
bool allow_stretch = true) const;
// Scales a raw XFB resolution to the target (display) aspect ratio
std::tuple<float, float> ScaleToDisplayAspectRatio(int width, int height,
bool allow_stretch = true) const;

2
Source/Core/VideoCommon/VideoConfig.cpp
View File

@ -128,7 +128,7 @@ void VideoConfig::Refresh()
sDumpEncoder = Config::Get(Config::GFX_DUMP_ENCODER);
sDumpPath = Config::Get(Config::GFX_DUMP_PATH);
iBitrateKbps = Config::Get(Config::GFX_BITRATE_KBPS);
bInternalResolutionFrameDumps = Config::Get(Config::GFX_INTERNAL_RESOLUTION_FRAME_DUMPS);
frame_dumps_resolution_type = Config::Get(Config::GFX_FRAME_DUMPS_RESOLUTION_TYPE);
bEnableGPUTextureDecoding = Config::Get(Config::GFX_ENABLE_GPU_TEXTURE_DECODING);
bPreferVSForLinePointExpansion = Config::Get(Config::GFX_PREFER_VS_FOR_LINE_POINT_EXPANSION);
bEnablePixelLighting = Config::Get(Config::GFX_ENABLE_PIXEL_LIGHTING);

13
Source/Core/VideoCommon/VideoConfig.h
View File

@ -80,6 +80,16 @@ enum class TriState : int
Auto
};
enum class FrameDumpResolutionType : int
{
// Window resolution (not including potential back buffer black borders)
WINDOW_RESOLUTION,
// The aspect ratio corrected XFB resolution (XFB pixels might not have been square)
XFB_ASPECT_RATIO_CORRECTED_RESOLUTION,
// The raw unscaled XFB resolution (based on "internal resolution" scale)
XFB_RAW_RESOLUTION,
};
// Bitmask containing information about which configuration has changed for the backend.
enum ConfigChangeBits : u32
{
@ -189,7 +199,8 @@ struct VideoConfig final
std::string sDumpEncoder;
std::string sDumpFormat;
std::string sDumpPath;
bool bInternalResolutionFrameDumps = false;
FrameDumpResolutionType frame_dumps_resolution_type =
FrameDumpResolutionType::XFB_ASPECT_RATIO_CORRECTED_RESOLUTION;
bool bBorderlessFullscreen = false;
bool bEnableGPUTextureDecoding = false;
bool bPreferVSForLinePointExpansion = false;