Replace std::clamp with MathUtils::SaturatingCast

Author: tygyh

Source/Core/AudioCommon/Mixer.cpp

@@ -334,8 +334,8 @@ void Mixer::SetGBAInputSampleRate(std::size_t device_number, u32 sample_rate)
 
 void Mixer::SetStreamingVolume(u32 lvolume, u32 rvolume)
 {
-  m_streaming_mixer.SetVolume(std::clamp<u32>(lvolume, 0x00, 0xff),
-                              std::clamp<u32>(rvolume, 0x00, 0xff));
+  m_streaming_mixer.SetVolume(MathUtil::SaturatingCast<u8>(lvolume),
+                              MathUtil::SaturatingCast<u8>(rvolume));
 }
 
 void Mixer::SetWiimoteSpeakerVolume(std::size_t wiimote_index, u32 lvolume, u32 rvolume)

Source/Core/Core/DSP/DSPAccelerator.cpp

@@ -154,8 +154,8 @@ u16 Accelerator::ReadSample(const s16* coefs)
     if (raw_sample >= 8)
       raw_sample -= 16;
 
-    s32 val32 = (scale * raw_sample) + ((0x400 + coef1 * m_yn1 + coef2 * m_yn2) >> 11);
-    val = static_cast<s16>(std::clamp<s32>(val32, -0x7FFF, 0x7FFF));
+    const s32 val32 = (scale * raw_sample) + ((0x400 + coef1 * m_yn1 + coef2 * m_yn2) >> 11);
+    val = MathUtil::SaturatingCast<s16>(val32);
     step_size = 2;
 
     m_yn2 = m_yn1;

Source/Core/Core/HW/DSPHLE/UCodes/AESnd.cpp

@@ -344,8 +344,8 @@ void AESndUCode::DoMixing()
       right += m_parameter_block.right;
       left += m_parameter_block.left;
       // Clamping from set40 mode
-      right = std::clamp(right, -32768, 32767);
-      left = std::clamp(left, -32768, 32767);
+      right = MathUtil::SaturatingCast<s16>(right);
+      left = MathUtil::SaturatingCast<s16>(left);
       m_output_buffer[sample_index * 2 + 0] = right;
       m_output_buffer[sample_index * 2 + 1] = left;
       sample_index++;
@@ -421,8 +421,8 @@ void AESndUCode::DoMixing()
         const s32 mixed_l = (static_cast<s32>(new_l) * m_parameter_block.volume_l) >> 8;
         const s32 mixed_r = (static_cast<s32>(new_r) * m_parameter_block.volume_r) >> 8;
         // Clamping from set40 mode
-        m_parameter_block.left = std::clamp(mixed_l, -32768, 32767);
-        m_parameter_block.right = std::clamp(mixed_r, -32768, 32767);
+        m_parameter_block.left = MathUtil::SaturatingCast<s16>(mixed_l);
+        m_parameter_block.right = MathUtil::SaturatingCast<s16>(mixed_r);
       }
       // no_mix - we don't need to do anything as we modify m_parameter_block.left/right in place
     }

Source/Core/Core/HW/DSPHLE/UCodes/ASnd.cpp

@@ -338,12 +338,12 @@ void ASndUCode::DoMixing(u32 return_mail)
       // "Mix right sample section"
       s32 sample_r = static_cast<s16>(m_output_buffer[buffer_offset]);
       sample_r += m_current_voice.right;
-      sample_r = std::clamp(sample_r, -32768, 32767);
+      sample_r = MathUtil::SaturatingCast<s16>(sample_r);
       m_output_buffer[buffer_offset++] = sample_r;
       // "Mix left sample section"
       s32 sample_l = static_cast<s16>(m_output_buffer[buffer_offset]);
       sample_l += m_current_voice.left;
-      sample_l = std::clamp(sample_l, -32768, 32767);
+      sample_l = MathUtil::SaturatingCast<s16>(sample_l);
       m_output_buffer[buffer_offset++] = sample_l;
       // "adds the counter with the voice frequency and test if it >=48000 to get the next sample"
       m_current_voice.counter += m_current_voice.freq;

Source/Core/Core/HW/DSPHLE/UCodes/AXVoice.h

@@ -356,7 +356,7 @@ void GetInputSamples(HLEAccelerator* accelerator, PB_TYPE& pb, s16* samples, u16
 
 s16 ClampS16(s64 sample)
 {
-  return std::clamp<s64>(sample, -0x8000, 0x7FFF);
+  return MathUtil::SaturatingCast<s16>(sample);
 }
 
 // Add samples to an output buffer, with optional volume ramping.

Source/Core/Core/HW/DSPHLE/UCodes/Zelda.cpp

@@ -1117,7 +1117,7 @@ void ZeldaAudioRenderer::ApplyReverb(bool post_rendering)
           for (u16 j = 0; j < 8; ++j)
             sample += (s32)buffer[i + j] * rpb.filter_coeffs[j];
           sample >>= 15;
-          buffer[i] = std::clamp(sample, -0x8000, 0x7FFF);
+          buffer[i] = MathUtil::SaturatingCast<s16>(sample);
         }
       };
 
@@ -1211,7 +1211,7 @@ void ZeldaAudioRenderer::ApplyLowPassFilter(MixingBuffer* buf, VPB* vpb)
     tmp *= coeff;
     tmp >>= 7;
     tmp += yn1;
-    s16 yn0 = std::clamp<s64>(tmp, -0x8000, 0x7FFF);
+    s16 yn0 = MathUtil::SaturatingCast<s16>(tmp);
     (*buf)[i] = yn0;
 
     yn1 = yn0;
@@ -1237,7 +1237,7 @@ void ZeldaAudioRenderer::ApplyBiquadFilter(MixingBuffer* buf, VPB* vpb)
     tmp += vpb->biquad_bn2 * xn2;
     tmp += vpb->biquad_an1 * yn1;
     tmp += vpb->biquad_an2 * yn2;
-    s16 yn0 = std::clamp<s64>(tmp >> 15, -0x8000, 0x7FFF);
+    s16 yn0 = MathUtil::SaturatingCast<s16>(tmp >> 15);
     (*buf)[i] = yn0;
 
     xn2 = xn1;
@@ -1626,7 +1626,7 @@ void ZeldaAudioRenderer::Resample(VPB* vpb, const s16* src, MixingBuffer* dst)
         dst_sample_unclamped += (s64)2 * coeffs[i] * input[i];
       dst_sample_unclamped >>= 16;
 
-      dst_sample = (s16)std::clamp<s64>(dst_sample_unclamped, -0x8000, 0x7FFF);
+      dst_sample = MathUtil::SaturatingCast<s16>(dst_sample_unclamped);
 
       pos += ratio;
     }
@@ -1874,7 +1874,7 @@ void ZeldaAudioRenderer::DecodeAFC(VPB* vpb, s16* dst, size_t block_count)
     {
       s32 sample = delta * nibble + yn1 * m_afc_coeffs[idx * 2] + yn2 * m_afc_coeffs[idx * 2 + 1];
       sample >>= 11;
-      sample = std::clamp(sample, -0x8000, 0x7fff);
+      sample = MathUtil::SaturatingCast<s16>(sample);
       *dst++ = (s16)sample;
       yn2 = yn1;
       yn1 = sample;

Source/Core/Core/HW/DSPHLE/UCodes/Zelda.h

@@ -7,6 +7,7 @@
 #include <array>
 
 #include "Common/CommonTypes.h"
+#include "Common/MathUtil.h"
 #include "Core/HW/DSPHLE/UCodes/UCodes.h"
 
 namespace Core
@@ -63,7 +64,7 @@ class ZeldaAudioRenderer
       s32 tmp = (u32)(*buf)[i] * (u32)vol;
       tmp >>= 16 - B;
 
-      (*buf)[i] = (s16)std::clamp(tmp, -0x8000, 0x7FFF);
+      (*buf)[i] = MathUtil::SaturatingCast<s16>(tmp);
     }
   }
   template <size_t N>
@@ -105,7 +106,7 @@ class ZeldaAudioRenderer
     while (count--)
     {
       s32 vol_src = ((s32)*src++ * (s32)vol) >> 15;
-      *dst++ += std::clamp(vol_src, -0x8000, 0x7FFF);
+      *dst++ += MathUtil::SaturatingCast<s16>(vol_src);
     }
   }
 

Source/Core/Core/HW/SI/SI_DeviceGCSteeringWheel.cpp

@@ -7,6 +7,7 @@
 
 #include "Common/CommonTypes.h"
 #include "Common/Logging/Log.h"
+#include "Common/MathUtil.h"
 #include "Core/HW/GCPad.h"
 
 namespace SerialInterface
@@ -78,10 +79,10 @@ DataResponse CSIDevice_GCSteeringWheel::GetData(u32& hi, u32& low)
     // but we'll have to redesign our GameCube controller input to fix that.
 
     // All 8 bits (Accelerate)
-    low |= u32(std::clamp(accel_value * 2, 0, 0xff)) << 24;
+    low |= static_cast<u32>(MathUtil::SaturatingCast<u8>(accel_value * 2)) << 24;
 
     // All 8 bits (Brake)
-    low |= u32(std::clamp(brake_value * 2, 0, 0xff)) << 16;
+    low |= static_cast<u32>(MathUtil::SaturatingCast<u8>(brake_value * 2)) << 16;
 
     HandleButtonCombos(pad_status);
   }

Source/Core/VideoBackends/Software/Rasterizer.cpp

@@ -177,7 +177,7 @@ static void Draw(s32 x, s32 y, s32 xi, s32 yi)
     for (int comp = 0; comp < 4; comp++)
     {
       const float color = ColorSlopes[i][comp].GetValue(x, y);
-      tev.Color[i][comp] = (u8)std::clamp<float>(color, 0.0f, 255.0f);
+      tev.Color[i][comp] = MathUtil::SaturatingCast<u8>(color);
     }
   }
 

Source/Core/VideoBackends/Software/SWEfbInterface.cpp

@@ -533,8 +533,8 @@ static u32 GammaCorrection(u32 color, const float gamma_rcp)
   u8 out_color[4];
   for (int i = BLU_C; i <= RED_C; i++)
   {
-    out_color[i] = static_cast<u8>(
-        std::clamp(std::pow(in_colors[i] / 255.0f, gamma_rcp) * 255.0f, 0.0f, 255.0f));
+    out_color[i] =
+        MathUtil::SaturatingCast<u8>(std::pow(in_colors[i] / 255.0f, gamma_rcp) * 255.0f);
   }
 
   u32 out_color32;