Merge pull request #11850 from Filoppi/post_process_fixes

Video: implement color correction to match the Wii/GC NTSC/PAL color spaces (and gamma)
2026-06-19 01:16:48 -07:00 · 2023-06-23 18:08:23 +02:00
parent 5bf3d55d38 daddf4cd9c
commit 02909bd1a5
34 changed files with 1016 additions and 142 deletions
@@ -0,0 +1,86 @@
+// References:
+// https://www.unravel.com.au/understanding-color-spaces
+
+// SMPTE 170M - BT.601 (NTSC-M) -> BT.709
+mat3 from_NTSCM = transpose(mat3(
+	0.939497225737661,		0.0502268452914346,		0.0102759289709032,
+	0.0177558637510127,		0.965824605885027,		0.0164195303639603,
+	-0.00162163209967010,	-0.00437400622653655,	1.00599563832621));
+
+// ARIB TR-B9 (9300K+27MPCD with chromatic adaptation) (NTSC-J) -> BT.709
+mat3 from_NTSCJ = transpose(mat3(
+	0.823613036967492,		-0.0943227111084757,	0.00799341532931119,
+	0.0289258355537324,		1.02310733489462,			0.00243547111576797,
+	-0.00569501554980891,	0.0161828357559315,		1.22328453915712));
+
+// EBU - BT.470BG/BT.601 (PAL) -> BT.709
+mat3 from_PAL = transpose(mat3(
+	1.04408168421813,		-0.0440816842181253,	0.000000000000000,
+	0.000000000000000,	1.00000000000000,			0.000000000000000,
+	0.000000000000000,	0.0118044782106489,		0.988195521789351));
+
+float3 LinearTosRGBGamma(float3 color)
+{
+	float a = 0.055;
+	
+	for (int i = 0; i < 3; ++i)
+	{
+		float x = color[i];
+		if (x <= 0.0031308)
+			x = x * 12.92;
+		else
+			x = (1.0 + a) * pow(x, 1.0 / 2.4) - a;
+		color[i] = x;
+	}
+
+	return color;
+}
+
+void main()
+{
+	// Note: sampling in gamma space is "wrong" if the source
+	// and target resolution don't match exactly.
+	// Fortunately at the moment here they always should but to do this correctly,
+	// we'd need to sample from 4 pixels, de-apply the gamma from each of these,
+	// and then do linear sampling on their corrected value.
+	float4 color = Sample();
+
+	// Convert to linear space to do any other kind of operation
+	color.rgb = pow(color.rgb, game_gamma.xxx);
+
+	if (OptionEnabled(correct_color_space))
+	{
+		if (game_color_space == 0)
+			color.rgb = color.rgb * from_NTSCM;
+		else if (game_color_space == 1)
+			color.rgb = color.rgb * from_NTSCJ;
+		else if (game_color_space == 2)
+			color.rgb = color.rgb * from_PAL;
+	}
+	
+	if (OptionEnabled(hdr_output))
+	{
+		const float hdr_paper_white = hdr_paper_white_nits / hdr_sdr_white_nits;
+		color.rgb *= hdr_paper_white;
+	}
+	
+	if (OptionEnabled(linear_space_output))
+	{
+		// Nothing to do here
+	}
+	// Correct the SDR gamma for sRGB (PC/Monitor) or ~2.2 (Common TV gamma)
+	else if (OptionEnabled(correct_gamma))
+	{
+		if (OptionEnabled(sdr_display_gamma_sRGB))
+			color.rgb = LinearTosRGBGamma(color.rgb);
+		else
+			color.rgb = pow(color.rgb, (1.0 / sdr_display_custom_gamma).xxx);
+	}
+	// Restore the original gamma without changes
+	else
+	{
+			color.rgb = pow(color.rgb, (1.0 / game_gamma).xxx);
+	}
+
+	SetOutput(color);
+}
@@ -128,6 +128,22 @@ const Info<bool> GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION{
    {System::GFX, "Enhancements", "ArbitraryMipmapDetection"}, true};
 const Info<float> GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD{
    {System::GFX, "Enhancements", "ArbitraryMipmapDetectionThreshold"}, 14.0f};
+const Info<bool> GFX_ENHANCE_HDR_OUTPUT{{System::GFX, "Enhancements", "HDROutput"}, false};
+
+// Color.Correction
+
+const Info<bool> GFX_CC_CORRECT_COLOR_SPACE{{System::GFX, "ColorCorrection", "CorrectColorSpace"},
+                                            false};
+const Info<ColorCorrectionRegion> GFX_CC_GAME_COLOR_SPACE{
+    {System::GFX, "ColorCorrection", "GameColorSpace"}, ColorCorrectionRegion::SMPTE_NTSCM};
+const Info<bool> GFX_CC_CORRECT_GAMMA{{System::GFX, "ColorCorrection", "CorrectGamma"}, false};
+const Info<float> GFX_CC_GAME_GAMMA{{System::GFX, "ColorCorrection", "GameGamma"}, 2.35f};
+const Info<bool> GFX_CC_SDR_DISPLAY_GAMMA_SRGB{
+    {System::GFX, "ColorCorrection", "SDRDisplayGammaSRGB"}, true};
+const Info<float> GFX_CC_SDR_DISPLAY_CUSTOM_GAMMA{
+    {System::GFX, "ColorCorrection", "SDRDisplayCustomGamma"}, 2.2f};
+const Info<float> GFX_CC_HDR_PAPER_WHITE_NITS{{System::GFX, "ColorCorrection", "HDRPaperWhiteNits"},
+                                              200.f};

 // Graphics.Stereoscopy

@@ -11,6 +11,7 @@ enum class AspectMode : int;
 enum class ShaderCompilationMode : int;
 enum class StereoMode : int;
 enum class TextureFilteringMode : int;
+enum class ColorCorrectionRegion : int;
 enum class TriState : int;

 namespace Config
@@ -105,6 +106,26 @@ extern const Info<bool> GFX_ENHANCE_FORCE_TRUE_COLOR;
 extern const Info<bool> GFX_ENHANCE_DISABLE_COPY_FILTER;
 extern const Info<bool> GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION;
 extern const Info<float> GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION_THRESHOLD;
+extern const Info<bool> GFX_ENHANCE_HDR_OUTPUT;
+
+// Color.Correction
+
+static constexpr float GFX_CC_GAME_GAMMA_MIN = 2.2f;
+static constexpr float GFX_CC_GAME_GAMMA_MAX = 2.8f;
+
+static constexpr float GFX_CC_DISPLAY_GAMMA_MIN = 2.2f;
+static constexpr float GFX_CC_DISPLAY_GAMMA_MAX = 2.4f;
+
+static constexpr float GFX_CC_HDR_PAPER_WHITE_NITS_MIN = 80.f;
+static constexpr float GFX_CC_HDR_PAPER_WHITE_NITS_MAX = 400.f;
+
+extern const Info<bool> GFX_CC_CORRECT_COLOR_SPACE;
+extern const Info<ColorCorrectionRegion> GFX_CC_GAME_COLOR_SPACE;
+extern const Info<bool> GFX_CC_CORRECT_GAMMA;
+extern const Info<float> GFX_CC_GAME_GAMMA;
+extern const Info<bool> GFX_CC_SDR_DISPLAY_GAMMA_SRGB;
+extern const Info<float> GFX_CC_SDR_DISPLAY_CUSTOM_GAMMA;
+extern const Info<float> GFX_CC_HDR_PAPER_WHITE_NITS;

 // Graphics.Stereoscopy

@@ -380,6 +380,7 @@ void DolphinAnalytics::MakePerGameBuilder()
  builder.AddData("cfg-gfx-internal-resolution", g_Config.iEFBScale);
  builder.AddData("cfg-gfx-tc-samples", g_Config.iSafeTextureCache_ColorSamples);
  builder.AddData("cfg-gfx-stereo-mode", static_cast<int>(g_Config.stereo_mode));
+  builder.AddData("cfg-gfx-hdr", static_cast<int>(g_Config.bHDR));
  builder.AddData("cfg-gfx-per-pixel-lighting", g_Config.bEnablePixelLighting);
  builder.AddData("cfg-gfx-shader-compilation-mode", GetShaderCompilationMode(g_Config));
  builder.AddData("cfg-gfx-wait-for-shaders", g_Config.bWaitForShadersBeforeStarting);
@@ -87,6 +87,8 @@ add_executable(dolphin-emu
  Config/Graphics/GraphicsWindow.h
  Config/Graphics/HacksWidget.cpp
  Config/Graphics/HacksWidget.h
+  Config/Graphics/ColorCorrectionConfigWindow.cpp
+  Config/Graphics/ColorCorrectionConfigWindow.h
  Config/Graphics/PostProcessingConfigWindow.cpp
  Config/Graphics/PostProcessingConfigWindow.h
  Config/GraphicsModListWidget.cpp
@@ -0,0 +1,181 @@
+// Copyright 2018 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include "DolphinQt/Config/Graphics/ColorCorrectionConfigWindow.h"
+
+#include <QCheckBox>
+#include <QDialogButtonBox>
+#include <QGridLayout>
+#include <QGroupBox>
+#include <QLabel>
+
+#include "Core/Config/GraphicsSettings.h"
+
+#include "DolphinQt/Config/ConfigControls/ConfigBool.h"
+#include "DolphinQt/Config/ConfigControls/ConfigChoice.h"
+#include "DolphinQt/Config/ConfigControls/ConfigFloatSlider.h"
+
+#include "VideoCommon/VideoConfig.h"
+
+ColorCorrectionConfigWindow::ColorCorrectionConfigWindow(QWidget* parent) : QDialog(parent)
+{
+  setWindowTitle(tr("Color Correction Configuration"));
+  setWindowFlags(windowFlags() & ~Qt::WindowContextHelpButtonHint);
+
+  Create();
+  ConnectWidgets();
+}
+
+void ColorCorrectionConfigWindow::Create()
+{
+  static const char TR_COLOR_SPACE_CORRECTION_DESCRIPTION[] = QT_TR_NOOP(
+      "Converts the colors to the color spaces that GC/Wii were meant to work with to sRGB/Rec.709."
+      "<br><br>There's no way of knowing what exact color space games were meant for,"
+      "<br>given there were multiple standards and most games didn't acknowledge them,"
+      "<br>so it's not correct to assume a format from the game disc region."
+      "<br>Just pick the one that looks more natural to you,"
+      " or match it with the region the game was developed in."
+      "<br><br>HDR output is required to show all the colors from the PAL and NTSC-J color spaces."
+      "<br><br><dolphin_emphasis>If unsure, leave this unchecked.</dolphin_emphasis>");
+  static const char TR_GAME_GAMMA_DESCRIPTION[] =
+      QT_TR_NOOP("NTSC-M and NTSC-J target gamma ~2.2. PAL targets gamma ~2.8."
+                 "<br>None of the two were necessarily followed by games or TVs. 2.35 is a good "
+                 "generic value for all regions."
+                 "<br>If a game allows you to chose a gamma value, match it here.");
+  static const char TR_GAMMA_CORRECTION_DESCRIPTION[] = QT_TR_NOOP(
+      "Converts the gamma from what the game targeted to what your current SDR display targets."
+      "<br>Monitors often target sRGB. TVs often target 2.2."
+      "<br><br><dolphin_emphasis>If unsure, leave this unchecked.</dolphin_emphasis>");
+
+  // Color Space:
+
+  auto* const color_space_box = new QGroupBox(tr("Color Space"));
+  auto* const color_space_layout = new QGridLayout();
+  color_space_layout->setVerticalSpacing(7);
+  color_space_layout->setColumnStretch(1, 1);
+  color_space_box->setLayout(color_space_layout);
+
+  m_correct_color_space =
+      new ConfigBool(tr("Correct Color Space"), Config::GFX_CC_CORRECT_COLOR_SPACE);
+  color_space_layout->addWidget(m_correct_color_space, 0, 0);
+  m_correct_color_space->SetDescription(tr(TR_COLOR_SPACE_CORRECTION_DESCRIPTION));
+
+  // "ColorCorrectionRegion"
+  const QStringList game_color_space_enum{tr("NTSC-M (SMPTE 170M)"), tr("NTSC-J (ARIB TR-B9)"),
+                                          tr("PAL (EBU)")};
+
+  m_game_color_space = new ConfigChoice(game_color_space_enum, Config::GFX_CC_GAME_COLOR_SPACE);
+  color_space_layout->addWidget(new QLabel(tr("Game Color Space")), 1, 0);
+  color_space_layout->addWidget(m_game_color_space, 1, 1);
+
+  m_game_color_space->setEnabled(m_correct_color_space->isChecked());
+
+  // Gamma:
+
+  auto* const gamma_box = new QGroupBox(tr("Gamma"));
+  auto* const gamma_layout = new QGridLayout();
+  gamma_layout->setVerticalSpacing(7);
+  gamma_layout->setColumnStretch(1, 1);
+  gamma_box->setLayout(gamma_layout);
+
+  m_game_gamma = new ConfigFloatSlider(Config::GFX_CC_GAME_GAMMA_MIN, Config::GFX_CC_GAME_GAMMA_MAX,
+                                       Config::GFX_CC_GAME_GAMMA, 0.01f);
+  gamma_layout->addWidget(new QLabel(tr("Game Gamma")), 0, 0);
+  gamma_layout->addWidget(m_game_gamma, 0, 1);
+  m_game_gamma->SetDescription(tr(TR_GAME_GAMMA_DESCRIPTION));
+  m_game_gamma_value = new QLabel(tr(""));
+  gamma_layout->addWidget(m_game_gamma_value, 0, 2);
+
+  m_correct_gamma = new ConfigBool(tr("Correct SDR Gamma"), Config::GFX_CC_CORRECT_GAMMA);
+  gamma_layout->addWidget(m_correct_gamma, 1, 0);
+  m_correct_gamma->SetDescription(tr(TR_GAMMA_CORRECTION_DESCRIPTION));
+
+  m_sdr_display_gamma_srgb =
+      new ConfigBool(tr("SDR Display Gamma sRGB"), Config::GFX_CC_SDR_DISPLAY_GAMMA_SRGB);
+  gamma_layout->addWidget(m_sdr_display_gamma_srgb, 2, 0);
+
+  m_sdr_display_custom_gamma =
+      new ConfigFloatSlider(Config::GFX_CC_DISPLAY_GAMMA_MIN, Config::GFX_CC_DISPLAY_GAMMA_MAX,
+                            Config::GFX_CC_SDR_DISPLAY_CUSTOM_GAMMA, 0.01f);
+  gamma_layout->addWidget(new QLabel(tr("SDR Display Custom Gamma")), 3, 0);
+  gamma_layout->addWidget(m_sdr_display_custom_gamma, 3, 1);
+  m_sdr_display_custom_gamma_value = new QLabel(tr(""));
+  gamma_layout->addWidget(m_sdr_display_custom_gamma_value, 3, 2);
+
+  m_sdr_display_gamma_srgb->setEnabled(m_correct_gamma->isChecked());
+  m_sdr_display_custom_gamma->setEnabled(m_correct_gamma->isChecked() &&
+                                         !m_sdr_display_gamma_srgb->isChecked());
+  m_game_gamma_value->setText(QString::asprintf("%f", m_game_gamma->GetValue()));
+  m_sdr_display_custom_gamma_value->setText(
+      QString::asprintf("%f", m_sdr_display_custom_gamma->GetValue()));
+
+  // HDR:
+
+  auto* const hdr_box = new QGroupBox(tr("HDR"));
+  auto* const hdr_layout = new QGridLayout();
+  hdr_layout->setVerticalSpacing(7);
+  hdr_layout->setColumnStretch(1, 1);
+  hdr_box->setLayout(hdr_layout);
+
+  m_hdr_paper_white_nits = new ConfigFloatSlider(Config::GFX_CC_HDR_PAPER_WHITE_NITS_MIN,
+                                                 Config::GFX_CC_HDR_PAPER_WHITE_NITS_MAX,
+                                                 Config::GFX_CC_HDR_PAPER_WHITE_NITS, 1.f);
+  hdr_layout->addWidget(new QLabel(tr("HDR Paper White Nits")), 0, 0);
+  hdr_layout->addWidget(m_hdr_paper_white_nits, 0, 1);
+  m_hdr_paper_white_nits_value = new QLabel(tr(""));
+  hdr_layout->addWidget(m_hdr_paper_white_nits_value, 0, 2);
+
+  m_hdr_paper_white_nits_value->setText(
+      QString::asprintf("%f", m_hdr_paper_white_nits->GetValue()));
+
+  // Other:
+
+  m_button_box = new QDialogButtonBox(QDialogButtonBox::Close);
+
+  auto* layout = new QVBoxLayout(this);
+  layout->setContentsMargins(0, 0, 0, 0);
+  layout->setAlignment(Qt::AlignTop);
+  layout->addWidget(color_space_box);
+  layout->addWidget(gamma_box);
+  layout->addWidget(hdr_box);
+  layout->addWidget(m_button_box);
+  setLayout(layout);
+}
+
+void ColorCorrectionConfigWindow::ConnectWidgets()
+{
+  connect(m_correct_color_space, &QCheckBox::toggled, this,
+          [this] { m_game_color_space->setEnabled(m_correct_color_space->isChecked()); });
+
+  connect(m_game_gamma, &ConfigFloatSlider::valueChanged, this, [this] {
+    m_game_gamma_value->setText(QString::asprintf("%f", m_game_gamma->GetValue()));
+  });
+
+  connect(m_correct_gamma, &QCheckBox::toggled, this, [this] {
+    // The "m_game_gamma" shouldn't be grayed out as it can still affect the color space correction
+
+    // For the moment we leave this enabled even when we are outputting in HDR
+    // (which means they'd have no influence on the final image),
+    // mostly because we don't have a simple way to determine if HDR is engaged from here
+    m_sdr_display_gamma_srgb->setEnabled(m_correct_gamma->isChecked());
+    m_sdr_display_custom_gamma->setEnabled(m_correct_gamma->isChecked() &&
+                                           !m_sdr_display_gamma_srgb->isChecked());
+  });
+
+  connect(m_sdr_display_gamma_srgb, &QCheckBox::toggled, this, [this] {
+    m_sdr_display_custom_gamma->setEnabled(m_correct_gamma->isChecked() &&
+                                           !m_sdr_display_gamma_srgb->isChecked());
+  });
+
+  connect(m_sdr_display_custom_gamma, &ConfigFloatSlider::valueChanged, this, [this] {
+    m_sdr_display_custom_gamma_value->setText(
+        QString::asprintf("%f", m_sdr_display_custom_gamma->GetValue()));
+  });
+
+  connect(m_hdr_paper_white_nits, &ConfigFloatSlider::valueChanged, this, [this] {
+    m_hdr_paper_white_nits_value->setText(
+        QString::asprintf("%f", m_hdr_paper_white_nits->GetValue()));
+  });
+
+  connect(m_button_box, &QDialogButtonBox::rejected, this, &QDialog::reject);
+}
@@ -0,0 +1,36 @@
+// Copyright 2018 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#pragma once
+
+#include <QDialog>
+
+class QWidget;
+class QLabel;
+class ConfigBool;
+class ConfigChoice;
+class ConfigFloatSlider;
+class QDialogButtonBox;
+
+class ColorCorrectionConfigWindow final : public QDialog
+{
+  Q_OBJECT
+public:
+  explicit ColorCorrectionConfigWindow(QWidget* parent);
+
+private:
+  void Create();
+  void ConnectWidgets();
+
+  ConfigBool* m_correct_color_space;
+  ConfigChoice* m_game_color_space;
+  ConfigFloatSlider* m_game_gamma;
+  QLabel* m_game_gamma_value;
+  ConfigBool* m_correct_gamma;
+  ConfigBool* m_sdr_display_gamma_srgb;
+  ConfigFloatSlider* m_sdr_display_custom_gamma;
+  QLabel* m_sdr_display_custom_gamma_value;
+  ConfigFloatSlider* m_hdr_paper_white_nits;
+  QLabel* m_hdr_paper_white_nits_value;
+  QDialogButtonBox* m_button_box;
+};
@@ -18,6 +18,7 @@
 #include "DolphinQt/Config/ConfigControls/ConfigChoice.h"
 #include "DolphinQt/Config/ConfigControls/ConfigRadio.h"
 #include "DolphinQt/Config/ConfigControls/ConfigSlider.h"
+#include "DolphinQt/Config/Graphics/ColorCorrectionConfigWindow.h"
 #include "DolphinQt/Config/Graphics/GraphicsWindow.h"
 #include "DolphinQt/Config/Graphics/PostProcessingConfigWindow.h"
 #include "DolphinQt/QtUtils/NonDefaultQPushButton.h"
@@ -102,6 +103,8 @@ void EnhancementsWidget::CreateWidgets()
  m_texture_filtering_combo->addItem(tr("Force Linear and 16x Anisotropic"),
                                     TEXTURE_FILTERING_FORCE_LINEAR_ANISO_16X);

+  m_configure_color_correction = new NonDefaultQPushButton(tr("Configure"));
+
  m_pp_effect = new ToolTipComboBox();
  m_configure_pp_effect = new NonDefaultQPushButton(tr("Configure"));
  m_scaled_efb_copy = new ConfigBool(tr("Scaled EFB Copy"), Config::GFX_HACK_COPY_EFB_SCALED);
@@ -116,6 +119,7 @@ void EnhancementsWidget::CreateWidgets()
      new ConfigBool(tr("Disable Copy Filter"), Config::GFX_ENHANCE_DISABLE_COPY_FILTER);
  m_arbitrary_mipmap_detection = new ConfigBool(tr("Arbitrary Mipmap Detection"),
                                                Config::GFX_ENHANCE_ARBITRARY_MIPMAP_DETECTION);
+  m_hdr = new ConfigBool(tr("HDR Post-Processing"), Config::GFX_ENHANCE_HDR_OUTPUT);

  int row = 0;
  enhancements_layout->addWidget(new QLabel(tr("Internal Resolution:")), row, 0);
@@ -130,6 +134,10 @@ void EnhancementsWidget::CreateWidgets()
  enhancements_layout->addWidget(m_texture_filtering_combo, row, 1, 1, -1);
  ++row;

+  enhancements_layout->addWidget(new QLabel(tr("Color Correction:")), row, 0);
+  enhancements_layout->addWidget(m_configure_color_correction, row, 1, 1, -1);
+  ++row;
+
  enhancements_layout->addWidget(new QLabel(tr("Post-Processing Effect:")), row, 0);
  enhancements_layout->addWidget(m_pp_effect, row, 1);
  enhancements_layout->addWidget(m_configure_pp_effect, row, 2);
@@ -148,6 +156,7 @@ void EnhancementsWidget::CreateWidgets()
  ++row;

  enhancements_layout->addWidget(m_disable_copy_filter, row, 0);
+  enhancements_layout->addWidget(m_hdr, row, 1, 1, -1);
  ++row;

  // Stereoscopy
@@ -188,11 +197,14 @@ void EnhancementsWidget::ConnectWidgets()
          [this](int) { SaveSettings(); });
  connect(m_3d_mode, qOverload<int>(&QComboBox::currentIndexChanged), [this] {
    m_block_save = true;
+    m_configure_color_correction->setEnabled(g_Config.backend_info.bSupportsPostProcessing);
    LoadPPShaders();
    m_block_save = false;

    SaveSettings();
  });
+  connect(m_configure_color_correction, &QPushButton::clicked, this,
+          &EnhancementsWidget::ConfigureColorCorrection);
  connect(m_configure_pp_effect, &QPushButton::clicked, this,
          &EnhancementsWidget::ConfigurePostProcessingShader);
 }
@@ -311,6 +323,8 @@ void EnhancementsWidget::LoadSettings()
    break;
  }

+  m_configure_color_correction->setEnabled(g_Config.backend_info.bSupportsPostProcessing);
+
  // Post Processing Shader
  LoadPPShaders();

@@ -320,6 +334,9 @@ void EnhancementsWidget::LoadSettings()
  m_3d_convergence->setEnabled(supports_stereoscopy);
  m_3d_depth->setEnabled(supports_stereoscopy);
  m_3d_swap_eyes->setEnabled(supports_stereoscopy);
+
+  m_hdr->setEnabled(g_Config.backend_info.bSupportsHDROutput);
+
  m_block_save = false;
 }

@@ -436,6 +453,9 @@ void EnhancementsWidget::AddDescriptions()
      "scaling filter selected by the game.<br><br>Any option except 'Default' will alter the look "
      "of the game's textures and might cause issues in a small number of "
      "games.<br><br><dolphin_emphasis>If unsure, select 'Default'.</dolphin_emphasis>");
+  static const char TR_COLOR_CORRECTION_DESCRIPTION[] =
+      QT_TR_NOOP("A group of features to make the colors more accurate,"
+                 " matching the color space Wii and GC games were meant for.");
  static const char TR_POSTPROCESSING_DESCRIPTION[] =
      QT_TR_NOOP("Applies a post-processing effect after rendering a frame.<br><br "
                 "/><dolphin_emphasis>If unsure, select (off).</dolphin_emphasis>");
@@ -498,6 +518,13 @@ void EnhancementsWidget::AddDescriptions()
      "reduce stutter in games that frequently load new textures. This feature is not compatible "
      "with GPU Texture Decoding.<br><br><dolphin_emphasis>If unsure, leave this "
      "checked.</dolphin_emphasis>");
+  static const char TR_HDR_DESCRIPTION[] = QT_TR_NOOP(
+      "Enables scRGB HDR output (if supported by your graphics backend and monitor)."
+      " Fullscreen might be required."
+      "<br><br>This gives post process shaders more room for accuracy, allows \"AutoHDR\" "
+      "post-process shaders to work, and allows to fully display the PAL and NTSC-J color spaces."
+      "<br><br>Note that games still render in SDR internally."
+      "<br><br><dolphin_emphasis>If unsure, leave this unchecked.</dolphin_emphasis>");

  m_ir_combo->SetTitle(tr("Internal Resolution"));
  m_ir_combo->SetDescription(tr(TR_INTERNAL_RESOLUTION_DESCRIPTION));
@@ -508,6 +535,8 @@ void EnhancementsWidget::AddDescriptions()
  m_texture_filtering_combo->SetTitle(tr("Texture Filtering"));
  m_texture_filtering_combo->SetDescription(tr(TR_FORCE_TEXTURE_FILTERING_DESCRIPTION));

+  m_configure_color_correction->setToolTip(tr(TR_COLOR_CORRECTION_DESCRIPTION));
+
  m_pp_effect->SetTitle(tr("Post-Processing Effect"));
  m_pp_effect->SetDescription(tr(TR_POSTPROCESSING_DESCRIPTION));

@@ -525,6 +554,8 @@ void EnhancementsWidget::AddDescriptions()

  m_arbitrary_mipmap_detection->SetDescription(tr(TR_ARBITRARY_MIPMAP_DETECTION_DESCRIPTION));

+  m_hdr->SetDescription(tr(TR_HDR_DESCRIPTION));
+
  m_3d_mode->SetTitle(tr("Stereoscopic 3D Mode"));
  m_3d_mode->SetDescription(tr(TR_3D_MODE_DESCRIPTION));

@@ -537,6 +568,11 @@ void EnhancementsWidget::AddDescriptions()
  m_3d_swap_eyes->SetDescription(tr(TR_3D_SWAP_EYES_DESCRIPTION));
 }

+void EnhancementsWidget::ConfigureColorCorrection()
+{
+  ColorCorrectionConfigWindow(this).exec();
+}
+
 void EnhancementsWidget::ConfigurePostProcessingShader()
 {
  const std::string shader = Config::Get(Config::GFX_ENHANCE_POST_SHADER);
@@ -30,6 +30,7 @@ private:
  void CreateWidgets();
  void ConnectWidgets();
  void AddDescriptions();
+  void ConfigureColorCorrection();
  void ConfigurePostProcessingShader();
  void LoadPPShaders();

@@ -38,6 +39,7 @@ private:
  ToolTipComboBox* m_aa_combo;
  ToolTipComboBox* m_texture_filtering_combo;
  ToolTipComboBox* m_pp_effect;
+  QPushButton* m_configure_color_correction;
  QPushButton* m_configure_pp_effect;
  ConfigBool* m_scaled_efb_copy;
  ConfigBool* m_per_pixel_lighting;
@@ -46,6 +48,7 @@ private:
  ConfigBool* m_force_24bit_color;
  ConfigBool* m_disable_copy_filter;
  ConfigBool* m_arbitrary_mipmap_detection;
+  ConfigBool* m_hdr;

  // Stereoscopy
  ConfigChoice* m_3d_mode;
@@ -80,6 +80,7 @@
    <ClCompile Include="Config\Graphics\GeneralWidget.cpp" />
    <ClCompile Include="Config\Graphics\GraphicsWindow.cpp" />
    <ClCompile Include="Config\Graphics\HacksWidget.cpp" />
+    <ClCompile Include="Config\Graphics\ColorCorrectionConfigWindow.cpp" />
    <ClCompile Include="Config\Graphics\PostProcessingConfigWindow.cpp" />
    <ClCompile Include="Config\GraphicsModListWidget.cpp" />
    <ClCompile Include="Config\GraphicsModWarningWidget.cpp" />
@@ -283,6 +284,7 @@
    <QtMoc Include="Config\Graphics\GeneralWidget.h" />
    <QtMoc Include="Config\Graphics\GraphicsWindow.h" />
    <QtMoc Include="Config\Graphics\HacksWidget.h" />
+    <QtMoc Include="Config\Graphics\ColorCorrectionConfigWindow.h" />
    <QtMoc Include="Config\Graphics\PostProcessingConfigWindow.h" />
    <QtMoc Include="Config\GraphicsModListWidget.h" />
    <QtMoc Include="Config\GraphicsModWarningWidget.h" />
@@ -15,6 +15,7 @@
 #include "VideoBackends/D3D/D3DState.h"
 #include "VideoBackends/D3D/DXTexture.h"
 #include "VideoBackends/D3DCommon/D3DCommon.h"
+#include "VideoCommon/FramebufferManager.h"
 #include "VideoCommon/VideoConfig.h"

 namespace DX11
@@ -202,12 +203,14 @@ std::vector<u32> GetAAModes(u32 adapter_index)
  if (temp_feature_level == D3D_FEATURE_LEVEL_10_0)
    return {};

+  const DXGI_FORMAT target_format =
+      D3DCommon::GetDXGIFormatForAbstractFormat(FramebufferManager::GetEFBColorFormat(), false);
  std::vector<u32> aa_modes;
  for (u32 samples = 1; samples <= D3D11_MAX_MULTISAMPLE_SAMPLE_COUNT; ++samples)
  {
    UINT quality_levels = 0;
-    if (SUCCEEDED(temp_device->CheckMultisampleQualityLevels(DXGI_FORMAT_R8G8B8A8_UNORM, samples,
-                                                             &quality_levels)) &&
+    if (SUCCEEDED(
+            temp_device->CheckMultisampleQualityLevels(target_format, samples, &quality_levels)) &&
        quality_levels > 0)
    {
      aa_modes.push_back(samples);
@@ -175,6 +175,9 @@ void Gfx::OnConfigChanged(u32 bits)
  // Quad-buffer changes require swap chain recreation.
  if (bits & CONFIG_CHANGE_BIT_STEREO_MODE && m_swap_chain)
    m_swap_chain->SetStereo(SwapChain::WantsStereo());
+
+  if (bits & CONFIG_CHANGE_BIT_HDR && m_swap_chain)
+    m_swap_chain->SetHDR(SwapChain::WantsHDR());
 }

 void Gfx::CheckForSwapChainChanges()
@@ -114,6 +114,7 @@ void VideoBackend::FillBackendInfo()
  g_Config.backend_info.bSupportsSettingObjectNames = true;
  g_Config.backend_info.bSupportsPartialMultisampleResolve = true;
  g_Config.backend_info.bSupportsDynamicVertexLoader = false;
+  g_Config.backend_info.bSupportsHDROutput = true;

  g_Config.backend_info.Adapters = D3DCommon::GetAdapterNames();
  g_Config.backend_info.AAModes = D3D::GetAAModes(g_Config.iAdapter);
@@ -21,7 +21,7 @@ std::unique_ptr<SwapChain> SwapChain::Create(const WindowSystemInfo& wsi)
 {
  std::unique_ptr<SwapChain> swap_chain =
      std::make_unique<SwapChain>(wsi, D3D::dxgi_factory.Get(), D3D::device.Get());
-  if (!swap_chain->CreateSwapChain(WantsStereo()))
+  if (!swap_chain->CreateSwapChain(WantsStereo(), WantsHDR()))
    return nullptr;

  return swap_chain;
@@ -421,6 +421,12 @@ void Gfx::OnConfigChanged(u32 bits)
    m_swap_chain->SetStereo(SwapChain::WantsStereo());
  }

+  if (m_swap_chain && bits & CONFIG_CHANGE_BIT_HDR)
+  {
+    ExecuteCommandList(true);
+    m_swap_chain->SetHDR(SwapChain::WantsHDR());
+  }
+
  // Wipe sampler cache if force texture filtering or anisotropy changes.
  if (bits & (CONFIG_CHANGE_BIT_ANISOTROPY | CONFIG_CHANGE_BIT_FORCE_TEXTURE_FILTERING))
  {
@@ -22,7 +22,7 @@ std::unique_ptr<SwapChain> SwapChain::Create(const WindowSystemInfo& wsi)
 {
  std::unique_ptr<SwapChain> swap_chain = std::make_unique<SwapChain>(
      wsi, g_dx_context->GetDXGIFactory(), g_dx_context->GetCommandQueue());
-  if (!swap_chain->CreateSwapChain(WantsStereo()))
+  if (!swap_chain->CreateSwapChain(WantsStereo(), WantsHDR()))
    return nullptr;

  return swap_chain;
@@ -16,6 +16,7 @@
 #include "VideoBackends/D3D12/Common.h"
 #include "VideoBackends/D3D12/D3D12StreamBuffer.h"
 #include "VideoBackends/D3D12/DescriptorHeapManager.h"
+#include "VideoCommon/FramebufferManager.h"
 #include "VideoCommon/VideoConfig.h"

 namespace DX12
@@ -65,11 +66,13 @@ std::vector<u32> DXContext::GetAAModes(u32 adapter_index)
      return {};
  }

+  const DXGI_FORMAT target_format =
+      D3DCommon::GetDXGIFormatForAbstractFormat(FramebufferManager::GetEFBColorFormat(), false);
  std::vector<u32> aa_modes;
  for (u32 samples = 1; samples < D3D12_MAX_MULTISAMPLE_SAMPLE_COUNT; ++samples)
  {
    D3D12_FEATURE_DATA_MULTISAMPLE_QUALITY_LEVELS multisample_quality_levels = {};
-    multisample_quality_levels.Format = DXGI_FORMAT_R8G8B8A8_UNORM;
+    multisample_quality_levels.Format = target_format;
    multisample_quality_levels.SampleCount = samples;

    temp_device->CheckFeatureSupport(D3D12_FEATURE_MULTISAMPLE_QUALITY_LEVELS,
@@ -90,6 +90,7 @@ void VideoBackend::FillBackendInfo()
  g_Config.backend_info.bSupportsPartialMultisampleResolve = true;
  g_Config.backend_info.bSupportsDynamicVertexLoader = true;
  g_Config.backend_info.bSupportsVSLinePointExpand = true;
+  g_Config.backend_info.bSupportsHDROutput = true;

  // We can only check texture support once we have a device.
  if (g_dx_context)
@@ -51,13 +51,18 @@ bool SwapChain::WantsStereo()
  return g_ActiveConfig.stereo_mode == StereoMode::QuadBuffer;
 }

+bool SwapChain::WantsHDR()
+{
+  return g_ActiveConfig.bHDR;
+}
+
 u32 SwapChain::GetSwapChainFlags() const
 {
  // This flag is necessary if we want to use a flip-model swapchain without locking the framerate
  return m_allow_tearing_supported ? DXGI_SWAP_CHAIN_FLAG_ALLOW_TEARING : 0;
 }

-bool SwapChain::CreateSwapChain(bool stereo)
+bool SwapChain::CreateSwapChain(bool stereo, bool hdr)
 {
  RECT client_rc;
  if (GetClientRect(static_cast<HWND>(m_wsi.render_surface), &client_rc))
@@ -66,6 +71,9 @@ bool SwapChain::CreateSwapChain(bool stereo)
    m_height = client_rc.bottom - client_rc.top;
  }

+  m_stereo = false;
+  m_hdr = false;
+
  // Try using the Win8 version if available.
  Microsoft::WRL::ComPtr<IDXGIFactory2> dxgi_factory2;
  HRESULT hr = m_dxgi_factory.As(&dxgi_factory2);
@@ -81,6 +89,7 @@ bool SwapChain::CreateSwapChain(bool stereo)
    swap_chain_desc.SampleDesc.Count = 1;
    swap_chain_desc.SampleDesc.Quality = 0;
    swap_chain_desc.Format = GetDXGIFormatForAbstractFormat(m_texture_format, false);
+
    swap_chain_desc.Scaling = DXGI_SCALING_STRETCH;
    swap_chain_desc.SwapEffect = DXGI_SWAP_EFFECT_FLIP_DISCARD;
    swap_chain_desc.Stereo = stereo;
@@ -108,6 +117,8 @@ bool SwapChain::CreateSwapChain(bool stereo)
  // support the newer DXGI interface aren't going to support DX12 anyway.
  if (FAILED(hr))
  {
+    hdr = false;
+
    DXGI_SWAP_CHAIN_DESC desc = {};
    desc.BufferDesc.Width = m_width;
    desc.BufferDesc.Height = m_height;
@@ -138,6 +149,37 @@ bool SwapChain::CreateSwapChain(bool stereo)
    WARN_LOG_FMT(VIDEO, "MakeWindowAssociation() failed: {}", Common::HRWrap(hr));

  m_stereo = stereo;
+
+  if (hdr)
+  {
+    // Only try to activate HDR here, to avoid failing when creating the swapchain
+    // (we can't know if the format is supported upfront)
+    Microsoft::WRL::ComPtr<IDXGISwapChain4> swap_chain4;
+    hr = m_swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain4));
+    if (SUCCEEDED(hr))
+    {
+      UINT color_space_support = 0;
+      // Note that this should succeed even if HDR is not currently engaged on the monitor,
+      // but it should display fine nonetheless.
+      // We need to check for DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020 as checking for
+      // scRGB always returns false (DX bug).
+      hr = swap_chain4->CheckColorSpaceSupport(DXGI_COLOR_SPACE_RGB_FULL_G2084_NONE_P2020,
+                                               &color_space_support);
+      if (SUCCEEDED(hr) && (color_space_support & DXGI_SWAP_CHAIN_COLOR_SPACE_SUPPORT_FLAG_PRESENT))
+      {
+        hr = swap_chain4->ResizeBuffers(SWAP_CHAIN_BUFFER_COUNT, 0, 0,
+                                        GetDXGIFormatForAbstractFormat(m_texture_format_hdr, false),
+                                        GetSwapChainFlags());
+        if (SUCCEEDED(hr))
+        {
+          hr = swap_chain4->SetColorSpace1(DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709);
+          if (SUCCEEDED(hr))
+            m_hdr = hdr;
+        }
+      }
+    }
+  }
+
  if (!CreateSwapChainBuffers())
  {
    PanicAlertFmt("Failed to create swap chain buffers");
@@ -164,12 +206,19 @@ bool SwapChain::ResizeSwapChain()
 {
  DestroySwapChainBuffers();

-  HRESULT hr = m_swap_chain->ResizeBuffers(SWAP_CHAIN_BUFFER_COUNT, 0, 0,
-                                           GetDXGIFormatForAbstractFormat(m_texture_format, false),
+  // The swap chain fills up the size of the window if no size is specified
+  HRESULT hr = m_swap_chain->ResizeBuffers(SWAP_CHAIN_BUFFER_COUNT, 0, 0, DXGI_FORMAT_UNKNOWN,
                                           GetSwapChainFlags());
+
  if (FAILED(hr))
    WARN_LOG_FMT(VIDEO, "ResizeBuffers() failed: {}", Common::HRWrap(hr));

+  Microsoft::WRL::ComPtr<IDXGISwapChain4> swap_chain4;
+  hr = m_swap_chain->QueryInterface(IID_PPV_ARGS(&swap_chain4));
+  if (SUCCEEDED(hr))
+    hr = swap_chain4->SetColorSpace1(m_hdr ? DXGI_COLOR_SPACE_RGB_FULL_G10_NONE_P709 :
+                                             DXGI_COLOR_SPACE_RGB_FULL_G22_NONE_P709);
+
  DXGI_SWAP_CHAIN_DESC desc;
  if (SUCCEEDED(m_swap_chain->GetDesc(&desc)))
  {
@@ -186,10 +235,28 @@ void SwapChain::SetStereo(bool stereo)
    return;

  DestroySwapChain();
-  if (!CreateSwapChain(stereo))
+  // Do not try to re-activate HDR here if it had already failed
+  if (!CreateSwapChain(stereo, m_hdr))
  {
    PanicAlertFmt("Failed to switch swap chain stereo mode");
-    CreateSwapChain(false);
+    CreateSwapChain(false, false);
+  }
+}
+
+void SwapChain::SetHDR(bool hdr)
+{
+  if (m_hdr == hdr)
+    return;
+
+  // NOTE: as an optimization here we could just call "ResizeSwapChain()"
+  // by adding some code to check if we could change the format to HDR.
+
+  DestroySwapChain();
+  // Do not try to re-activate stereo mode here if it had already failed
+  if (!CreateSwapChain(m_stereo, hdr))
+  {
+    PanicAlertFmt("Failed to switch swap chain SDR/HDR mode");
+    CreateSwapChain(false, false);
  }
 }

@@ -249,7 +316,8 @@ bool SwapChain::ChangeSurface(void* native_handle)
 {
  DestroySwapChain();
  m_wsi.render_surface = native_handle;
-  return CreateSwapChain(m_stereo);
+  // We only keep the swap chain settings (HDR/Stereo) that had successfully applied beofre
+  return CreateSwapChain(m_stereo, m_hdr);
 }

 }  // namespace D3DCommon
@@ -25,8 +25,13 @@ public:
  // Returns true if the stereo mode is quad-buffering.
  static bool WantsStereo();

+  static bool WantsHDR();
+
  IDXGISwapChain* GetDXGISwapChain() const { return m_swap_chain.Get(); }
-  AbstractTextureFormat GetFormat() const { return m_texture_format; }
+  AbstractTextureFormat GetFormat() const
+  {
+    return m_hdr ? m_texture_format_hdr : m_texture_format;
+  }
  u32 GetWidth() const { return m_width; }
  u32 GetHeight() const { return m_height; }

@@ -43,10 +48,11 @@ public:
  bool ChangeSurface(void* native_handle);
  bool ResizeSwapChain();
  void SetStereo(bool stereo);
+  void SetHDR(bool hdr);

 protected:
  u32 GetSwapChainFlags() const;
-  bool CreateSwapChain(bool stereo);
+  bool CreateSwapChain(bool stereo = false, bool hdr = false);
  void DestroySwapChain();

  virtual bool CreateSwapChainBuffers() = 0;
@@ -56,12 +62,14 @@ protected:
  Microsoft::WRL::ComPtr<IDXGIFactory> m_dxgi_factory;
  Microsoft::WRL::ComPtr<IDXGISwapChain> m_swap_chain;
  Microsoft::WRL::ComPtr<IUnknown> m_d3d_device;
-  AbstractTextureFormat m_texture_format = AbstractTextureFormat::RGBA8;
+  const AbstractTextureFormat m_texture_format = AbstractTextureFormat::RGB10_A2;
+  const AbstractTextureFormat m_texture_format_hdr = AbstractTextureFormat::RGBA16F;

  u32 m_width = 1;
  u32 m_height = 1;

  bool m_stereo = false;
+  bool m_hdr = false;
  bool m_allow_tearing_supported = false;
  bool m_has_fullscreen = false;
  bool m_fullscreen_request = false;
--- a/Show More
+++ b/Show More