Fix: Explicit float casts for Android NDK compilation

Add static_cast<f32>() to integer-to-float conversions in audio_core
to satisfy Android NDK's -Werror=implicit-int-float-conversion flag.

Fixes compilation errors in fft.cpp, loudness_calculator.cpp, and
limiter.cpp on Android builds.

Signed-off-by: Zephyron <zephyron@citron-emu.org>

src/audio_core/common/fft.cpp

@@ -130,7 +130,7 @@ void FFT::FFTInternal(std::span<std::complex<f32>> data, u32 size, bool inverse)
     std::copy(temp.begin(), temp.end(), data.begin());
 
     const f32 direction = inverse ? 1.0f : -1.0f;
-    const f32 scale = inverse ? (1.0f / size) : 1.0f;
+    const f32 scale = inverse ? (1.0f / static_cast<f32>(size)) : 1.0f;
 
     // FFT stages
     const u32 log2_size = static_cast<u32>(std::bit_width(size - 1u));
@@ -139,7 +139,7 @@ void FFT::FFTInternal(std::span<std::complex<f32>> data, u32 size, bool inverse)
         const u32 m2 = m / 2;
 
         const std::complex<f32> wm = std::exp(std::complex<f32>(
-            0.0f, direction * 2.0f * std::numbers::pi_v<f32> / m));
+            0.0f, direction * 2.0f * std::numbers::pi_v<f32> / static_cast<f32>(m)));
 
         for (u32 k = 0; k < size; k += m) {
             std::complex<f32> w = 1.0f;

src/audio_core/common/loudness_calculator.cpp

@@ -67,7 +67,7 @@ void LoudnessCalculator::InitializeKWeightingFilter() {
     // Shelf filter (high-shelf +4dB at high frequencies)
     const f32 f0_shelf = 1681.974450955533f;
     const f32 Q_shelf = 0.7071752369554193f;
-    const f32 K_shelf = std::tan(std::numbers::pi_v<f32> * f0_shelf / params_.sample_rate);
+    const f32 K_shelf = std::tan(std::numbers::pi_v<f32> * f0_shelf / static_cast<f32>(params_.sample_rate));
     const f32 Vh_shelf = std::pow(10.0f, 4.0f / 20.0f);
     const f32 Vb_shelf = std::pow(Vh_shelf, 0.4996667741545416f);
 
@@ -81,7 +81,7 @@ void LoudnessCalculator::InitializeKWeightingFilter() {
     // High-pass filter (48Hz cutoff)
     const f32 f0_hp = 38.13547087602444f;
     const f32 Q_hp = 0.5003270373238773f;
-    const f32 K_hp = std::tan(std::numbers::pi_v<f32> * f0_hp / params_.sample_rate);
+    const f32 K_hp = std::tan(std::numbers::pi_v<f32> * f0_hp / static_cast<f32>(params_.sample_rate));
 
     const f32 a0_hp = 1.0f + K_hp / Q_hp + K_hp * K_hp;
     k_filter_.b0_hp = 1.0f / a0_hp;
@@ -138,7 +138,7 @@ void LoudnessCalculator::Analyze(std::span<const f32> samples, u32 sample_count)
         }
 
         // Calculate mean square
-        const f32 mean_square = sum_square / params_.channel_count;
+        const f32 mean_square = sum_square / static_cast<f32>(params_.channel_count);
 
         // Update buffers
         momentary_buffer_[buffer_index_ % momentary_buffer_.size()] = mean_square;
@@ -152,25 +152,25 @@ void LoudnessCalculator::Analyze(std::span<const f32> samples, u32 sample_count)
 
     // Calculate momentary loudness (last 400ms)
     const size_t momentary_samples = std::min(buffer_index_,
-        static_cast<size_t>(params_.sample_rate * 0.4f));
+        static_cast<size_t>(static_cast<f32>(params_.sample_rate) * 0.4f));
     f32 momentary_sum = 0.0f;
     for (size_t i = 0; i < momentary_samples; i++) {
         momentary_sum += momentary_buffer_[i];
     }
-    momentary_loudness_ = CalculateLoudness(momentary_sum / momentary_samples);
+    momentary_loudness_ = CalculateLoudness(momentary_sum / static_cast<f32>(momentary_samples));
 
     // Calculate short-term loudness (last 3s)
     const size_t short_term_samples = std::min(buffer_index_,
-        static_cast<size_t>(params_.sample_rate * 3.0f));
+        static_cast<size_t>(static_cast<f32>(params_.sample_rate) * 3.0f));
     f32 short_term_sum = 0.0f;
     for (size_t i = 0; i < short_term_samples; i++) {
         short_term_sum += short_term_buffer_[i];
     }
-    short_term_loudness_ = CalculateLoudness(short_term_sum / short_term_samples);
+    short_term_loudness_ = CalculateLoudness(short_term_sum / static_cast<f32>(short_term_samples));
 
     // Calculate integrated loudness
     if (integrated_count_ > 0) {
-        integrated_loudness_ = CalculateLoudness(integrated_sum_ / integrated_count_);
+        integrated_loudness_ = CalculateLoudness(integrated_sum_ / static_cast<f32>(integrated_count_));
     }
 }
 

src/audio_core/renderer/command/effect/limiter.cpp

@@ -33,9 +33,9 @@ void LimiterCommand::Process(const AudioRenderer::CommandListProcessor& processo
     if (effect_enabled) {
         // Convert parameters
         const f32 attack_coeff =
-            std::exp(-1.0f / (parameter.attack_time * processor.target_sample_rate / 1000.0f));
+            std::exp(-1.0f / (parameter.attack_time * static_cast<f32>(processor.target_sample_rate) / 1000.0f));
         const f32 release_coeff =
-            std::exp(-1.0f / (parameter.release_time * processor.target_sample_rate / 1000.0f));
+            std::exp(-1.0f / (parameter.release_time * static_cast<f32>(processor.target_sample_rate) / 1000.0f));
         const f32 threshold_linear = std::pow(10.0f, parameter.threshold / 20.0f);
         const f32 makeup_gain_linear = std::pow(10.0f, parameter.makeup_gain / 20.0f);
 
@@ -69,7 +69,7 @@ void LimiterCommand::Process(const AudioRenderer::CommandListProcessor& processo
             const f32 total_gain = gain * makeup_gain_linear;
             for (u32 ch = 0; ch < parameter.channel_count; ch++) {
                 output_buffers[ch][sample] =
-                    static_cast<s32>(input_buffers[ch][sample] * total_gain);
+                    static_cast<s32>(static_cast<f32>(input_buffers[ch][sample]) * total_gain);
             }
         }
     } else {