[优化视频渲染]: 引入gamma校正和默认构造函数改进

- 增加了gamma校正功能，通过在filter.cc和video_color.frag中添加gamma参数，允许用户调整视频的gamma值，从而优化画面效果。 - 更新了openglrender.cc，为shader程序添加了gamma值的uniform设置，确保gamma校正可以在OpenGL渲染过程中应用。 - 调整了shaderutils.cc，将gamma调整逻辑加入到片段着色器的生成过程中。 - 优化了equalizer.cc，为Equalizer类添加了对gamma值的支持，包括ffGamma和eqGamma方法，以及相应的范围设置。 - 改进了equalizer.hpp，增加了gamma相关的方法声明，以支持新的gamma调整功能。 - 对utils.cpp中的Utils::rangeMap函数进行了小幅度重构，增加了断言以确保传入参数的有效性，并简化了代码结构。
RealChuan · Jun 14, 2024 · 990e441 · 990e441
1 parent b4518fb
commit 990e441
Show file tree

Hide file tree

Showing 7 changed files with 60 additions and 43 deletions.
diff --git a/src/ffmpeg/filter/filter.cc b/src/ffmpeg/filter/filter.cc
@@ -161,10 +161,11 @@ auto Filter::scale(const QSize &size) -> QString
 
 auto Filter::ep(const MediaConfig::Equalizer &equalizer) -> QString
 {
-    return QString("eq=contrast=%1:saturation=%2:brightness=%3")
+    return QString("eq=contrast=%1:saturation=%2:brightness=%3:gamma=%4")
         .arg(QString::number(equalizer.eqContrast()),
              QString::number(equalizer.eqSaturation()),
-             QString::number(equalizer.eqBrightness()));
+             QString::number(equalizer.eqBrightness()),
+             QString::number(equalizer.eqGamma()));
 }
 
 // need z.lib libzimg support zscale

diff --git a/src/ffmpeg/videorender/openglrender.cc b/src/ffmpeg/videorender/openglrender.cc
@@ -299,6 +299,7 @@ void OpenglRender::paintVideoFrame()
     d_ptr->programPtr->setUniformValue("contrast", m_equalizer.ffContrast());
     d_ptr->programPtr->setUniformValue("saturation", m_equalizer.ffSaturation());
     d_ptr->programPtr->setUniformValue("brightness", m_equalizer.ffBrightness());
+    d_ptr->programPtr->setUniformValue("gamma", m_equalizer.ffGamma());
     draw();
     d_ptr->programPtr->release();
     d_ptr->frameChanged = false;

diff --git a/src/ffmpeg/videorender/shader/video_color.frag b/src/ffmpeg/videorender/shader/video_color.frag
@@ -1,6 +1,7 @@
 uniform float contrast;
 uniform float saturation;
 uniform float brightness;
+uniform float gamma;
 
 vec3 adjustBrightness(vec3 rgb, float brightness) // 调整亮度
 {
@@ -41,3 +42,9 @@ vec3 adjustSaturation(vec3 rgb, float saturation) // 调整饱和度
     hsv.y = hsv.y * saturation;
     return hsv2Rgb(hsv);
 }
+
+vec3 adjustGamma(vec3 rgb, float gamma) // 调整gamma
+{
+    gamma = clamp(gamma, 0.1, 10.0);
+    return pow(rgb, vec3(1.0 / gamma));
+}
diff --git a/src/ffmpeg/videorender/shaderutils.cc b/src/ffmpeg/videorender/shaderutils.cc
@@ -185,6 +185,7 @@ void finishFragment(QByteArray &frag)
     frag.append(GLSL(color.rgb = adjustContrast(color.rgb, contrast);\n));
     frag.append(GLSL(color.rgb = adjustSaturation(color.rgb, saturation);\n));
     frag.append(GLSL(color.rgb = adjustBrightness(color.rgb, brightness);\n));
+    frag.append(GLSL(color.rgb = adjustGamma(color.rgb, gamma);\n));
     frag.append(GLSL(FragColor = color;\n));
 }
 

diff --git a/src/mediaconfig/equalizer.cc b/src/mediaconfig/equalizer.cc
@@ -7,7 +7,7 @@ namespace MediaConfig {
 class Equalizer::EqualizerPrivate
 {
 public:
-    EqualizerPrivate(Equalizer *q)
+    explicit EqualizerPrivate(Equalizer *q)
         : q_ptr(q)
         , contrastRange(-100, 100)
         , saturationRange(-100, 100)
@@ -45,7 +45,7 @@ Equalizer::Equalizer(const Equalizer &other)
     d_ptr->hueRange = other.d_ptr->hueRange;
 }
 
-Equalizer &Equalizer::operator=(const Equalizer &other)
+auto Equalizer::operator=(const Equalizer &other) -> Equalizer &
 {
     d_ptr->contrastRange = other.d_ptr->contrastRange;
     d_ptr->saturationRange = other.d_ptr->saturationRange;
@@ -56,9 +56,9 @@ Equalizer &Equalizer::operator=(const Equalizer &other)
     return *this;
 }
 
-Equalizer::~Equalizer() {}
+Equalizer::~Equalizer() = default;
 
-bool Equalizer::operator==(const Equalizer &other) const
+auto Equalizer::operator==(const Equalizer &other) const -> bool
 {
     return d_ptr->contrastRange == other.d_ptr->contrastRange
            && d_ptr->saturationRange == other.d_ptr->saturationRange
@@ -67,92 +67,98 @@ bool Equalizer::operator==(const Equalizer &other) const
            && d_ptr->hueRange == other.d_ptr->hueRange;
 }
 
-bool Equalizer::operator!=(const Equalizer &other) const
+auto Equalizer::operator!=(const Equalizer &other) const -> bool
 {
     return !(*this == other);
 }
 
-Equalizer::EqualizerRange &Equalizer::contrastRange() const
+auto Equalizer::contrastRange() const -> Equalizer::EqualizerRange &
 {
     return d_ptr->contrastRange;
 }
 
-float Equalizer::ffContrast() const
+auto Equalizer::ffContrast() const -> float
 {
-    return Utils::rangeMap(d_ptr->contrastRange.value(),
-                           d_ptr->contrastRange.min(),
-                           d_ptr->contrastRange.max(),
-                           0.0,
-                           2.0);
+    return eqContrast();
 }
 
-float Equalizer::eqContrast() const
+auto Equalizer::eqContrast() const -> float
 {
+    // The value must be a float value in range -1000.0 to 1000.0. The default value is "1".
     return Utils::rangeMap(d_ptr->contrastRange.value(),
                            d_ptr->contrastRange.min(),
                            d_ptr->contrastRange.max(),
-                           0.0,
+                           -0.0,
                            2.0);
-    // The value must be a float value in range -1000.0 to 1000.0. The default value is "1".
 }
 
-Equalizer::EqualizerRange &Equalizer::saturationRange() const
+auto Equalizer::saturationRange() const -> Equalizer::EqualizerRange &
 {
     return d_ptr->saturationRange;
 }
 
-float Equalizer::ffSaturation() const
+auto Equalizer::ffSaturation() const -> float
 {
-    return Utils::rangeMap(d_ptr->saturationRange.value(),
-                           d_ptr->saturationRange.min(),
-                           d_ptr->saturationRange.max(),
-                           0.0,
-                           2.0);
+    return eqSaturation();
 }
 
-float Equalizer::eqSaturation() const
+auto Equalizer::eqSaturation() const -> float
 {
     // The value must be a float in range 0.0 to 3.0. The default value is "1".
     auto value = d_ptr->saturationRange.value();
     if (value == 0) {
         return 1.0;
     }
-    if (value > 1) {
+    if (value > 0) {
         return Utils::rangeMap(value, 0, d_ptr->saturationRange.max(), 1.0, 3.0);
     }
     return Utils::rangeMap(value, d_ptr->saturationRange.min(), 0, 0, 1.0);
 }
 
-Equalizer::EqualizerRange &Equalizer::brightnessRange() const
+auto Equalizer::brightnessRange() const -> Equalizer::EqualizerRange &
 {
     return d_ptr->brightnessRange;
 }
 
-float Equalizer::ffBrightness() const
+auto Equalizer::ffBrightness() const -> float
 {
-    return Utils::rangeMap(d_ptr->brightnessRange.value(),
-                           d_ptr->brightnessRange.min(),
-                           d_ptr->brightnessRange.max(),
-                           -1,
-                           1.0);
+    return eqBrightness();
 }
 
-float Equalizer::eqBrightness() const
+auto Equalizer::eqBrightness() const -> float
 {
+    // The value must be a float value in range -1.0 to 1.0. The default value is "0".
     return Utils::rangeMap(d_ptr->brightnessRange.value(),
                            d_ptr->brightnessRange.min(),
                            d_ptr->brightnessRange.max(),
-                           -1,
-                           1);
-    // The value must be a float value in range -1000.0 to 1000.0. The default value is "1".
+                           -1.0,
+                           1.0);
 }
 
-Equalizer::EqualizerRange &Equalizer::gammaRange() const
+auto Equalizer::gammaRange() const -> Equalizer::EqualizerRange &
 {
     return d_ptr->gammaRange;
 }
 
-Equalizer::EqualizerRange &Equalizer::hueRange() const
+auto Equalizer::ffGamma() const -> float
+{
+    return eqGamma();
+}
+
+auto Equalizer::eqGamma() const -> float
+{
+    // The value must be a float in range 0.1 to 10.0. The default value is "1".
+    auto value = d_ptr->gammaRange.value();
+    if (value == 0) {
+        return 1.0;
+    }
+    if (value > 0) {
+        return Utils::rangeMap(value, 0, d_ptr->gammaRange.max(), 1.0, 10.0);
+    }
+    return Utils::rangeMap(value, d_ptr->gammaRange.min(), 0, 0.1, 1.0);
+}
+
+auto Equalizer::hueRange() const -> Equalizer::EqualizerRange &
 {
     return d_ptr->hueRange;
 }

diff --git a/src/mediaconfig/equalizer.hpp b/src/mediaconfig/equalizer.hpp
@@ -35,6 +35,8 @@ class MEDIACONFIG_EXPORT Equalizer
     [[nodiscard]] auto eqBrightness() const -> float;
 
     [[nodiscard]] auto gammaRange() const -> EqualizerRange &;
+    [[nodiscard]] auto ffGamma() const -> float;
+    [[nodiscard]] auto eqGamma() const -> float;
 
     [[nodiscard]] auto hueRange() const -> EqualizerRange &;
 

diff --git a/src/utils/utils.cpp b/src/utils/utils.cpp
@@ -18,7 +18,7 @@ void Utils::setSurfaceFormatVersion(int major, int minor)
     QSurfaceFormat::setDefaultFormat(surfaceFormat);
 }
 
-QByteArray Utils::readAllFile(const QString &filePath)
+auto Utils::readAllFile(const QString &filePath) -> QByteArray
 {
     QFile file(filePath);
     if (!file.open(QIODevice::ReadOnly)) {
@@ -30,10 +30,9 @@ QByteArray Utils::readAllFile(const QString &filePath)
     return buf;
 }
 
-float Utils::rangeMap(float value, float min, float max, float newMin, float newMax)
+auto Utils::rangeMap(float value, float min, float max, float newMin, float newMax) -> float
 {
-    Q_ASSERT(min <= max);
-    Q_ASSERT(newMin <= newMax);
+    Q_ASSERT(min <= max && newMin <= newMax);
     Q_ASSERT(min <= value && value <= max);
     return (value - min) * (newMax - newMin) / (max - min) + newMin;
 }