fix: snap illegal AAC sample rates to 48 kHz on Windows

electron/native/wgc-capture/CMakeLists.txt

@@ -89,3 +89,25 @@ target_link_libraries(cursor-sampler PRIVATE
   gdi32
   gdiplus
 )
+
+add_executable(audio_sample_utils_test
+  src/audio_sample_utils.cpp
+  src/audio_sample_utils.h
+  src/audio_sample_utils_test.cpp
+)
+
+target_compile_definitions(audio_sample_utils_test PRIVATE
+  NOMINMAX
+  WIN32_LEAN_AND_MEAN
+  _WIN32_WINNT=0x0A00
+)
+
+target_compile_options(audio_sample_utils_test PRIVATE /EHsc /W4 /utf-8)
+
+target_link_libraries(audio_sample_utils_test PRIVATE
+  mf
+  mfplat
+  mfreadwrite
+  mfuuid
+  ole32
+)

electron/native/wgc-capture/src/audio_sample_utils.cpp

@@ -87,6 +87,21 @@ double readMappedChannel(const BYTE* source, const AudioInputFormat& format, siz
     return readSampleAsDouble(source, format, frameIndex, std::min(targetChannel, format.channels - 1));
 }
 
+UINT32 aacCompatibleSampleRate(UINT32 sampleRate) {
+    constexpr UINT32 kAacSampleRates[] = {
+        8000, 11025, 12000, 16000, 22050, 24000, 32000, 44100, 48000,
+    };
+    if (sampleRate == 0) {
+        return 48000;
+    }
+    for (UINT32 rate : kAacSampleRates) {
+        if (sampleRate == rate) {
+            return rate;
+        }
+    }
+    return 48000;
+}
+
 } // namespace
 
 constexpr int64_t HnsPerSecond = 10'000'000;
@@ -100,10 +115,16 @@ bool sameAudioFormatForMixing(const AudioInputFormat& left, const AudioInputForm
            left.avgBytesPerSec == right.avgBytesPerSec;
 }
 
+// Microsoft AAC encoder (MFAudioFormat_AAC) sample rates. WASAPI loopback
+// often reports 96000 or 192000; those are legal PCM mix rates but not AAC
+// input rates, and SetInputMediaType then fails with MF_E_INVALIDMEDIATYPE
+// (0xc00d36b4). Keep legal rates as-is so a working 44100/48000 path is
+// unchanged; snap everything else (including 0) to 48000. The mixer already
+// resamples through convertAudioWithGain when the source rate differs.
 AudioInputFormat makeAacCompatibleAudioFormat(const AudioInputFormat& source) {
     AudioInputFormat format{};
     format.subtype = MFAudioFormat_PCM;
-    format.sampleRate = source.sampleRate > 0 ? source.sampleRate : 48000;
+    format.sampleRate = aacCompatibleSampleRate(source.sampleRate);
     format.channels = 2;
     format.bitsPerSample = 16;
     format.blockAlign = format.channels * (format.bitsPerSample / 8);
@@ -186,24 +207,61 @@ void convertAudioWithGain(
         return;
     }
 
+    // Integer-factor downsample (96 kHz / 192 kHz -> 48 kHz): average each
+    // group of source frames instead of picking one. Nearest-neighbour
+    // decimation aliases content above the new Nyquist into the recording.
+    if (sourceFormat.sampleRate > targetFormat.sampleRate &&
+        sourceFormat.sampleRate % targetFormat.sampleRate == 0) {
+        const UINT32 factor = sourceFormat.sampleRate / targetFormat.sampleRate;
+        const size_t targetFrames = sourceFrames / factor;
+        if (targetFrames > 0) {
+            destination.assign(targetFrames * targetFormat.blockAlign, 0);
+            for (size_t targetFrame = 0; targetFrame < targetFrames; ++targetFrame) {
+                for (UINT32 channel = 0; channel < targetFormat.channels; ++channel) {
+                    double sum = 0.0;
+                    for (UINT32 tap = 0; tap < factor; ++tap) {
+                        sum += readMappedChannel(
+                            source,
+                            sourceFormat,
+                            targetFrame * factor + tap,
+                            channel,
+                            targetFormat.channels);
+                    }
+                    writeSampleFromDouble(
+                        destination.data(),
+                        targetFormat,
+                        targetFrame,
+                        channel,
+                        (sum / static_cast<double>(factor)) * gain);
+                }
+            }
+            return;
+        }
+        // Too few source frames for one averaged output frame (tiny WASAPI
+        // packets). Fall through to interpolation instead of dropping them.
+    }
+
     const double rateRatio = static_cast<double>(targetFormat.sampleRate) /
         static_cast<double>(sourceFormat.sampleRate);
     const size_t targetFrames = std::max<size_t>(1, static_cast<size_t>(std::llround(sourceFrames * rateRatio)));
     destination.assign(targetFrames * targetFormat.blockAlign, 0);
 
     for (size_t targetFrame = 0; targetFrame < targetFrames; ++targetFrame) {
         const double sourcePosition = static_cast<double>(targetFrame) / rateRatio;
-        const size_t sourceFrame = std::min(
-            sourceFrames - 1,
-            static_cast<size_t>(std::llround(sourcePosition)));
+        const size_t sourceFrame = std::min(sourceFrames - 1, static_cast<size_t>(sourcePosition));
+        const size_t nextFrame = std::min(sourceFrames - 1, sourceFrame + 1);
+        const double frac = sourcePosition - static_cast<double>(sourceFrame);
         for (UINT32 channel = 0; channel < targetFormat.channels; ++channel) {
-            const double sample = readMappedChannel(
-                source,
-                sourceFormat,
-                sourceFrame,
+            const double a = readMappedChannel(
+                source, sourceFormat, sourceFrame, channel, targetFormat.channels);
+            const double b = readMappedChannel(
+                source, sourceFormat, nextFrame, channel, targetFormat.channels);
+            writeSampleFromDouble(
+                destination.data(),
+                targetFormat,
+                targetFrame,
                 channel,
-                targetFormat.channels);
-            writeSampleFromDouble(destination.data(), targetFormat, targetFrame, channel, sample * gain);
+                (a + (b - a) * frac) * gain);
         }
     }
 }