Merge pull request #2378 from google/hieuhh/frequency_dual_test

Porting the frequency tests from CtsVerifier to OboeTester

Author: HoangHongHieu

apps/OboeTester/app/CMakeLists.txt

@@ -6,7 +6,7 @@ set(CMAKE_CXX_FLAGS_RELEASE "${CMAKE_CXX_FLAGS_RELEASE} -O3")
 
 link_directories(${CMAKE_CURRENT_LIST_DIR}/..)
 
-# Increment this number when adding files to OboeTester => 112
+# Increment this number when adding files to OboeTester => 113
 # The change in this file will help Android Studio resync
 # and generate new build files that reference the new code.
 file(GLOB_RECURSE app_native_sources src/main/cpp/*)

apps/OboeTester/app/src/main/AndroidManifest.xml

@@ -135,6 +135,14 @@
             android:label="@string/title_rapid_cycle"
             android:exported="true"
             android:screenOrientation="portrait" />
+        <activity android:name=".FrequencyActivity"
+            android:label="Frequency Test"
+            android:exported="true"
+            android:screenOrientation="portrait"/>
+        <activity android:name=".DualFrequencyActivity"
+            android:label="Dual Frequency Test"
+            android:exported="true"
+            android:screenOrientation="portrait"/>
         <activity
             android:name=".AudioWorkloadTestActivity"
             android:label="@string/title_audio_workload_test"

apps/OboeTester/app/src/main/cpp/NativeAudioContext.cpp

@@ -933,6 +933,29 @@ void ActivityDataPath::finishOpen(bool isInput, std::shared_ptr<oboe::AudioStrea
     }
 }
 
+// ======================================================================= ActivityFrequency
+void ActivityFrequency::configureBuilder(bool isInput, oboe::AudioStreamBuilder &builder) {
+    ActivityFullDuplex::configureBuilder(isInput, builder);
+
+    if (mFullDuplexAnalyzer.get() == nullptr) {
+        mFullDuplexAnalyzer = std::make_unique<FullDuplexAnalyzer>(&mFrequencyAnalyzer);
+    }
+    if (!isInput) {
+        // Output uses a callback, input is polled by the analyzer.
+        builder.setCallback(oboeCallbackProxy.get());
+        oboeCallbackProxy->setDataCallback(mFullDuplexAnalyzer.get());
+    }
+}
+
+void ActivityFrequency::finishOpen(bool isInput, std::shared_ptr<oboe::AudioStream> &oboeStream) {
+    if (isInput) {
+        mFullDuplexAnalyzer->setSharedInputStream(oboeStream);
+        mFullDuplexAnalyzer->setRecording(mRecording.get());
+    } else {
+        mFullDuplexAnalyzer->setSharedOutputStream(oboeStream);
+    }
+}
+
 // =================================================================== ActivityTestDisconnect
 ActivityTestDisconnect::ActivityTestDisconnect() {
     mRoutingCallback = std::make_shared<TestRoutingCallback>(this);

apps/OboeTester/app/src/main/cpp/NativeAudioContext.h

@@ -53,6 +53,7 @@
 #include "FullDuplexEcho.h"
 #include "analyzer/GlitchAnalyzer.h"
 #include "analyzer/DataPathAnalyzer.h"
+#include "analyzer/FrequencyAnalyzer.h"
 #include "InputStreamCallbackAnalyzer.h"
 #include "MultiChannelRecording.h"
 #include "NoisePulseGenerator.h"
@@ -308,6 +309,8 @@ class ActivityContext {
 
     virtual void setSignalType(int signalType) {}
 
+    virtual void setBalance(float balance) {}
+
     virtual void setAmplitude(float amplitude) {}
 
     virtual void setDuck(bool isDucked) {}
@@ -867,6 +870,47 @@ class ActivityTestDisconnect : public ActivityContext {
     std::shared_ptr<oboe::flowgraph::SinkFloat>   mSinkFloat;
 };
 
+/**
+ * Test frequency
+ */
+class ActivityFrequency : public ActivityFullDuplex {
+ public:
+  ActivityFrequency() {
+      mFullDuplexAnalyzer = std::make_unique<FullDuplexAnalyzer>(&mFrequencyAnalyzer);
+  }
+  virtual ~ActivityFrequency() = default;
+
+  oboe::Result startStreams() override {
+      mFrequencyAnalyzer.reset();
+      return mFullDuplexAnalyzer->start();
+  }
+
+  void configureBuilder(bool isInput, oboe::AudioStreamBuilder &builder) override;
+
+  void setSignalType(int signalType) override {
+      mFrequencyAnalyzer.setSignalType(signalType);
+  }
+
+  void setBalance(float balance) override {
+      mFrequencyAnalyzer.setBalance(balance);
+  }
+
+  FrequencyAnalyzer *getFrequencyAnalyzer() {
+      return &mFrequencyAnalyzer;
+  }
+
+  FullDuplexAnalyzer *getFullDuplexAnalyzer() override {
+      return mFullDuplexAnalyzer.get();
+  }
+
+ protected:
+  void finishOpen(bool isInput, std::shared_ptr<oboe::AudioStream> &oboeStream) override;
+
+ private:
+  std::unique_ptr<FullDuplexAnalyzer> mFullDuplexAnalyzer;
+  FrequencyAnalyzer mFrequencyAnalyzer;
+};
+
 /**
  * Global context for native tests.
  * Switch between various ActivityContexts.
@@ -910,6 +954,12 @@ class NativeAudioContext {
             case ActivityType::DataPath:
                 currentActivity = &mActivityDataPath;
                 break;
+            case ActivityType::Frequency:
+                currentActivity = &mActivityFrequency;
+                break;
+            case ActivityType::DualFrequency:
+                currentActivity = &mActivityFrequency;
+                break;
         }
     }
 
@@ -926,6 +976,7 @@ class NativeAudioContext {
     ActivityGlitches             mActivityGlitches;
     ActivityDataPath             mActivityDataPath;
     ActivityTestDisconnect       mActivityTestDisconnect;
+    ActivityFrequency            mActivityFrequency;
 
 private:
 
@@ -941,6 +992,8 @@ class NativeAudioContext {
         Glitches = 6,
         TestDisconnect = 7,
         DataPath = 8,
+        Frequency = 10,
+        DualFrequency = 11,
     };
 
     ActivityType                 mActivityType = ActivityType::Undefined;

apps/OboeTester/app/src/main/cpp/analyzer/AverageBuffer.h

@@ -0,0 +1,67 @@
+/*
+ * Copyright (C) 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef OBOETESTER_AVERAGEBUFFER_H
+#define OBOETESTER_AVERAGEBUFFER_H
+
+#include <vector>
+#include <algorithm>
+
+class AverageBuffer {
+public:
+    AverageBuffer() = default;
+
+    void resize(size_t size) {
+        mAccumulator.resize(size);
+        clear();
+    }
+
+    void clear() {
+        std::fill(mAccumulator.begin(), mAccumulator.end(), 0.0);
+        mCount = 0;
+    }
+
+    void accumulate(const double* data, size_t size) {
+        if (size > mAccumulator.size()) {
+            mAccumulator.resize(size, 0.0);
+        }
+        for (size_t i = 0; i < size; ++i) {
+            mAccumulator[i] += data[i];
+        }
+        mCount++;
+    }
+
+    int getCount() const {
+        return mCount;
+    }
+
+    size_t size() const {
+        return mAccumulator.size();
+    }
+
+    double getAverageAt(size_t index) const {
+        if (mCount > 0 && index < mAccumulator.size()) {
+            return mAccumulator[index] / mCount;
+        }
+        return 0.0;
+    }
+
+private:
+    std::vector<double> mAccumulator;
+    int mCount = 0;
+};
+
+#endif //OBOETESTER_AVERAGEBUFFER_H

apps/OboeTester/app/src/main/cpp/analyzer/FrequencyAnalyzer.cpp

@@ -0,0 +1,170 @@
+/*
+ * Copyright (C) 2026 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#include "FrequencyAnalyzer.h"
+#include <math.h>
+#include "fft.h"
+
+FrequencyAnalyzer::FrequencyAnalyzer() : LoopbackProcessor() {
+    mWindow.resize(WINDOW_SIZE);
+    mIncoherentPower = 0.0;
+    mWindowSum = 0.0;
+    for (int i = 0; i < WINDOW_SIZE; i++) {
+        mWindow[i] = 0.5 * (1.0 - cos(2.0 * M_PI * i / (WINDOW_SIZE - 1)));
+        mIncoherentPower += mWindow[i] * mWindow[i];
+        mWindowSum += mWindow[i];
+    }
+    mInputBuffer.resize(WINDOW_SIZE);
+    mAverageBuffer.resize(WINDOW_SIZE / 2);
+
+    mInputBufferIndex = 0;
+    mFramesAccumulated = 0;
+    mOutputPhase = 0.0f;
+
+    std::lock_guard<std::mutex> lock(mFftBufferLock);
+    mFftMagnitudeBuffer.clear();
+}
+
+void FrequencyAnalyzer::reset() {
+    LoopbackProcessor::reset();
+    mInputBufferIndex = 0;
+    mOutputPhase = 0.0f;
+
+    mAverageBuffer.clear();
+    mFramesAccumulated = 0;
+
+    std::lock_guard<std::mutex> lock(mFftBufferLock);
+    mFftMagnitudeBuffer.clear();
+}
+
+void FrequencyAnalyzer::prepareToTest() {
+    LoopbackProcessor::prepareToTest();
+    mPhaseIncrement = 2.0 * M_PI * SINE_WAVE_FREQUENCY / getSampleRate();
+    mMeasurementWindowFrames = MEASUREMENT_TIME_SEC * getSampleRate();
+}
+
+LoopbackProcessor::result_code FrequencyAnalyzer::processInputFrame(const float* frameData,
+                                                                    int channelCount) {
+    float sample = frameData[getInputChannel()];
+    mInputBuffer[mInputBufferIndex++] = sample;
+    if (mInputBufferIndex >= WINDOW_SIZE) {
+        // Perform FFT
+        std::lock_guard<std::mutex> lock(mFftBufferLock);
+        CVector fftInput(WINDOW_SIZE);
+        for (int i = 0; i < WINDOW_SIZE; i++) {
+            double windowed = mInputBuffer[i] * mWindow[i];
+            fftInput[i] = Complex(windowed, 0);
+        }
+        fft(fftInput);
+
+        // Accumulate magnitude
+        std::vector<double> currentMagnitudes(WINDOW_SIZE / 2);
+        for (int i = 0; i < WINDOW_SIZE / 2; i++) {
+            double mag;
+            if (mSignalType == 1) { // Sine
+                mag = 2.0 * std::abs(fftInput[i]) / mWindowSum;
+            } else {
+                mag = 4.0 * std::abs(fftInput[i]) / std::sqrt(mIncoherentPower);
+            }
+            if (mag < 1e-9) mag = 1e-9; // to prevent log(0)
+            currentMagnitudes[i] = mag;
+        }
+        mAverageBuffer.accumulate(currentMagnitudes.data(),
+                                  currentMagnitudes.size());
+        mInputBufferIndex = 0;
+    }
+
+    mFramesAccumulated++;
+    if (mFramesAccumulated >= mMeasurementWindowFrames) {
+        // End of measurement window! Compute the average and save it to mFftMagnitudeBuffer
+        std::lock_guard<std::mutex> lock(mFftBufferLock);
+        if (mFftMagnitudeBuffer.empty()) {
+            // First measurement window
+            mFftMagnitudeBuffer.resize(WINDOW_SIZE / 2);
+        }
+        for (int i = 0; i < WINDOW_SIZE / 2; i++) {
+            double avgMag = mAverageBuffer.getAverageAt(i);
+            double dbfs = 20.0 * std::log10(avgMag);
+            mFftMagnitudeBuffer[i] = static_cast<float>(dbfs);
+        }
+        mAverageBuffer.clear();
+        mFramesAccumulated = 0;
+    }
+
+    return RESULT_OK;
+}
+
+void FrequencyAnalyzer::setSignalType(int signalType) {
+    mSignalType = signalType;
+}
+
+int FrequencyAnalyzer::getWindowSize() {
+    return WINDOW_SIZE;
+}
+
+LoopbackProcessor::result_code FrequencyAnalyzer::processOutputFrame(float* frameData,
+                                                                     int channelCount) {
+    float output = 0.0f;
+    if (mSignalType == 0) { // White noise
+        output = mWhiteNoise.nextRandomDouble() * mAmplitude;
+    } else if (mSignalType == 1) { // Sine
+        output = sin(mOutputPhase) * mAmplitude;
+        mOutputPhase += mPhaseIncrement;
+        if (mOutputPhase >= M_PI * 2) mOutputPhase -= M_PI * 2;
+    } else if (mSignalType == 2) { // Silence
+        output = 0.0f;
+    }
+    if (channelCount == 2) {
+        float leftGain = (mBalance <= 0.5f) ? 1.0f : 2.0f * (1.0f - mBalance);
+        float rightGain = (mBalance >= 0.5f) ? 1.0f : 2.0f * mBalance;
+        frameData[0] = output * leftGain;
+        frameData[1] = output * rightGain;
+    } else {
+        for (int i = 0; i < channelCount; i++) {
+            frameData[i] = output;
+        }
+    }
+    return RESULT_OK;
+}
+
+std::string FrequencyAnalyzer::analyze() {
+    return "FrequencyAnalyzer: Analysis the frequency magnitude";
+}
+
+bool FrequencyAnalyzer::isDone() {
+    return false;
+}
+
+int FrequencyAnalyzer::getFftMagnitude(float* buffer, int length) {
+    std::lock_guard<std::mutex> lock(mFftBufferLock);
+    if (mFftMagnitudeBuffer.empty()) {
+        return 0;
+    }
+    int numToCopy = std::min(length, (int) (WINDOW_SIZE / 2));
+    for (int i = 0; i < numToCopy; i++) {
+        buffer[i] = mFftMagnitudeBuffer[i];
+    }
+    return numToCopy;
+}
+
+int FrequencyAnalyzer::getFftFrequencies(float* buffer, int length) {
+    int numToCopy = std::min(length, (int) (WINDOW_SIZE / 2));
+    double sampleRate = getSampleRate();
+    for (int i = 0; i < numToCopy; i++) {
+        buffer[i] = (float) (i * sampleRate / WINDOW_SIZE);
+    }
+    return numToCopy;
+}