lq-audio-studio 4.0.0 → 4.0.1

package/android/build.gradle

@@ -81,6 +81,7 @@ android {
     versionCode 1
     versionName "0.1.0"
     testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    consumerProguardFiles "consumer-rules.pro"
     externalNativeBuild {
       cmake {
         cppFlags "-frtti -fexceptions -Wall"
@@ -140,4 +141,4 @@ kotlin {
   jvmToolchain {
     languageVersion.set(JavaLanguageVersion.of(17))
   }
-}
+}

package/android/consumer-rules.pro

@@ -0,0 +1 @@
+-keep class com.aozora.audio.AozoraWebRtcApm { *; }

package/android/src/main/java/com/aozora/audio/AozoraWebRtcApm.java

@@ -0,0 +1,36 @@
+package com.aozora.audio;
+
+/** Stable JNI boundary for the bundled WebRTC Audio Processing Module. */
+public final class AozoraWebRtcApm {
+    private static final boolean AVAILABLE;
+
+    static {
+        boolean loaded;
+        try {
+            System.loadLibrary("aozora_apm");
+            loaded = true;
+        } catch (Throwable error) {
+            loaded = false;
+        }
+        AVAILABLE = loaded;
+    }
+
+    private AozoraWebRtcApm() {}
+
+    public static boolean isAvailable() {
+        return AVAILABLE;
+    }
+
+    public static native long nativeCreate(
+        int sampleRate,
+        int channels,
+        boolean echoCancellation,
+        boolean noiseSuppression,
+        boolean gainControl
+    );
+    public static native int nativeProcessReverse(long handle, short[] samples);
+    public static native int nativeProcessCapture(long handle, short[] samples);
+    public static native void nativeSetStreamDelay(long handle, int delayMs);
+    public static native int nativeGetVoiceDetected(long handle);
+    public static native void nativeRelease(long handle);
+}

package/android/src/main/java/net/siteed/audiostudio/AudioProcessing.kt

@@ -0,0 +1,95 @@
+package net.siteed.audiostudio
+
+internal enum class AudioProcessingBackend(val wireValue: String) {
+    DISABLED("disabled"),
+    SYSTEM("system"),
+    WEBRTC("webrtc"),
+    UNAVAILABLE("unavailable"),
+}
+
+internal data class AudioProcessingRequest(
+    val echoCancellation: Boolean,
+    val noiseSuppression: Boolean,
+    val automaticGainControl: Boolean,
+) {
+    val anyEnabled: Boolean
+        get() = echoCancellation || noiseSuppression || automaticGainControl
+
+    companion object {
+        fun from(config: AndroidAudioProcessingConfig) = AudioProcessingRequest(
+            echoCancellation = config.echoCancellation,
+            noiseSuppression = config.noiseSuppression,
+            automaticGainControl = config.automaticGainControl,
+        )
+    }
+}
+
+internal data class SystemAudioProcessingStatus(
+    val aec: Boolean = false,
+    val noiseSuppression: Boolean = false,
+    val automaticGainControl: Boolean = false,
+)
+
+internal data class AudioProcessingPlan(
+    val system: AudioProcessingRequest,
+    val software: AudioProcessingRequest,
+) {
+    companion object {
+        fun create(
+            config: AndroidAudioProcessingConfig,
+            systemStatus: SystemAudioProcessingStatus,
+        ): AudioProcessingPlan {
+            val requested = AudioProcessingRequest.from(config)
+            val system = when (config.mode) {
+                AndroidAudioProcessingMode.SOFTWARE -> AudioProcessingRequest(false, false, false)
+                else -> requested
+            }
+            val software = when (config.mode) {
+                AndroidAudioProcessingMode.SYSTEM -> AudioProcessingRequest(false, false, false)
+                AndroidAudioProcessingMode.SOFTWARE -> requested
+                AndroidAudioProcessingMode.SYSTEM_WITH_SOFTWARE_FALLBACK -> AudioProcessingRequest(
+                    echoCancellation = requested.echoCancellation && !systemStatus.aec,
+                    noiseSuppression = requested.noiseSuppression && !systemStatus.noiseSuppression,
+                    automaticGainControl = requested.automaticGainControl && !systemStatus.automaticGainControl,
+                )
+            }
+            return AudioProcessingPlan(system = system, software = software)
+        }
+    }
+}
+
+internal data class AudioProcessingStatus(
+    val mode: String,
+    val aec: AudioProcessingBackend,
+    val noiseSuppression: AudioProcessingBackend,
+    val automaticGainControl: AudioProcessingBackend,
+    val reverseStreamConnected: Boolean,
+    val sampleRate: Int,
+    val channels: Int,
+    val frameDurationMs: Int = 10,
+    val compressedOutputProcessed: Boolean = false,
+) {
+    fun toMap(): Map<String, Any> = mapOf(
+        "mode" to mode,
+        "aec" to aec.wireValue,
+        "noiseSuppression" to noiseSuppression.wireValue,
+        "automaticGainControl" to automaticGainControl.wireValue,
+        "reverseStreamConnected" to reverseStreamConnected,
+        "sampleRate" to sampleRate,
+        "channels" to channels,
+        "frameDurationMs" to frameDurationMs,
+        "compressedOutputProcessed" to compressedOutputProcessed,
+    )
+
+    companion object {
+        fun disabled(sampleRate: Int = 0, channels: Int = 0) = AudioProcessingStatus(
+            mode = "disabled",
+            aec = AudioProcessingBackend.DISABLED,
+            noiseSuppression = AudioProcessingBackend.DISABLED,
+            automaticGainControl = AudioProcessingBackend.DISABLED,
+            reverseStreamConnected = false,
+            sampleRate = sampleRate,
+            channels = channels,
+        )
+    }
+}

package/android/src/main/java/net/siteed/audiostudio/AudioRecorderManager.kt

@@ -151,6 +151,10 @@ class AudioRecorderManager(
     private val audioSourceLifecycle = AudioSourceLifecycle<AudioSourceResolver.Resolution>()
     /** Platform AEC/ANS/AGC attached to the current VOICE_COMMUNICATION AudioRecord session. */
     private var voiceProcessingEffects: VoiceProcessingEffects? = null
+    /** WebRTC APM processing only the effects the platform session could not enable. */
+    private var softwareAudioProcessor: WebRtcAudioFrameProcessor? = null
+    private var audioProcessingConfigInUse: AndroidAudioProcessingConfig? = null
+    private var systemAudioProcessingStatus = SystemAudioProcessingStatus()
 
     /**
      * The resolved source, for use after the recorders exist. Reading this before resolution
@@ -1113,6 +1117,7 @@ class AudioRecorderManager(
                     // The source actually opened, which may differ from the request when the
                     // device does not support it (#428).
                     "androidAudioSource" to requireAudioSource.name,
+                    "audioProcessing" to currentAudioProcessingStatus().toMap(),
                     "compression" to if (compressedFile != null) bundleOf(
                         "mimeType" to if (recordingConfig.output.compressed.format == "aac") "audio/aac" else "audio/opus",
                         "bitrate" to recordingConfig.output.compressed.bitrate,
@@ -1564,18 +1569,13 @@ class AudioRecorderManager(
                     return false
                 }
 
-                // VOICE_COMMUNICATION selects the device's communication capture path, but
-                // that alone did not attach any effects on the Lenovo/Qualcomm target (the
-                // AudioFlinger dump showed 0 Effect Chains). Bind each available platform
-                // AEC/ANS/AGC effect to this concrete AudioRecord session so the system has
-                // an explicit chain. A route change or interruption creates a new session
-                // and reaches this block again; teardown releases the previous chain first.
+                // Rebuild the complete processing chain with each AudioRecord session. USB
+                // route changes and interruption recovery replace the Android session ID.
                 releaseVoiceProcessingEffects()
-                if (currentSource.name == "voiceCommunication") {
-                    voiceProcessingEffects = VoiceProcessingEffects.attach(
-                        checkNotNull(audioRecord).audioSessionId
-                    )
-                }
+                configureAudioProcessing(
+                    currentSourceName = currentSource.name,
+                    audioSessionId = checkNotNull(audioRecord).audioSessionId,
+                )
             }
             return true
 
@@ -2174,7 +2174,8 @@ class AudioRecorderManager(
                     "isPaused" to false,
                     "mime" to mimeType,
                     "size" to 0,
-                    "interval" to if (::recordingConfig.isInitialized) recordingConfig.interval else 0
+                    "interval" to if (::recordingConfig.isInitialized) recordingConfig.interval else 0,
+                    "audioProcessing" to currentAudioProcessingStatus().toMap(),
                 )
             }
 
@@ -2226,6 +2227,7 @@ class AudioRecorderManager(
                 "interval" to recordingConfig.interval,
                 "maxDurationMs" to if (recordingConfig.maxDurationMs > 0) recordingConfig.maxDurationMs else null,
                 "maxDurationReached" to maxDurationReached,
+                "audioProcessing" to currentAudioProcessingStatus().toMap(),
                 "compression" to compressionBundle
             )
         }
@@ -2317,6 +2319,9 @@ class AudioRecorderManager(
             } else {
                 null
             }
+            // Keep the analysis accumulator in the same scope as the APM tail flush.
+            // Otherwise the final partial capture frame cannot be forwarded to analysis.
+            val accumulatedAnalysisData = ByteArrayOutputStream()
             
             try {
                 // Write audio data directly to the file (if not skipping)
@@ -2325,7 +2330,6 @@ class AudioRecorderManager(
                 
                 // Buffer to accumulate data
                 accumulatedAudioData = ByteArrayOutputStream()
-                val accumulatedAnalysisData = ByteArrayOutputStream()  // Separate buffer for analysis
                 audioFileHandler.writeWavHeader(
                     accumulatedAudioData!!,
                     recordingConfig.sampleRate,
@@ -2380,6 +2384,7 @@ class AudioRecorderManager(
                     shouldProcessAnalysis = recordingConfig.enableProcessing && 
                         (isFirstAnalysis || timeSinceLastAnalysis >= recordingConfig.intervalAnalysis)
 
+                    var processedAudioData: ByteArray? = null
                     val bytesRead = synchronized(audioRecordLock) {
                         if (
                             sessionId != recordingSession ||
@@ -2429,26 +2434,31 @@ class AudioRecorderManager(
                                     // budget left and its next failure silently suppressed.
                                     failedDeliveryAttempts.remove(RecordingErrorKind.INPUT_READ)
                                     failedDeliveryAttempts.remove(RecordingErrorKind.INPUT_STATE)
+                                    processedAudioData = softwareAudioProcessor
+                                        ?.processCapture(audioData, bytes)
+                                        ?: audioData.copyOf(bytes)
                                 }
                             }
                         } ?: -1 // Handle null case
                     }
 
-                    if (bytesRead > 0) {
+                    val processedChunk = processedAudioData
+                    if (bytesRead > 0 && processedChunk != null && processedChunk.isNotEmpty()) {
+                        val processedBytesRead = processedChunk.size
                         // Only write to file if primary output is enabled
                         if (fos != null) {
-                            fos.write(audioData, 0, bytesRead)
-                            cachedPrimaryFileSize += bytesRead  // Update cached file size
+                            fos.write(processedChunk, 0, processedBytesRead)
+                            cachedPrimaryFileSize += processedBytesRead  // Update cached file size
                         }
-                        totalDataSize += bytesRead
+                        totalDataSize += processedBytesRead
                         
-                        accumulatedAudioData?.write(audioData, 0, bytesRead)
+                        accumulatedAudioData?.write(processedChunk, 0, processedBytesRead)
                         
                         // Always accumulate data for analysis if enabled (moved outside shouldProcessAnalysis check)
                         if (recordingConfig.enableProcessing) {
                             // Check buffer size to prevent OOM on low-RAM devices with extreme configs
-                            if (accumulatedAnalysisData.size() + bytesRead <= MAX_ANALYSIS_BUFFER_SIZE) {
-                                accumulatedAnalysisData.write(audioData, 0, bytesRead)
+                            if (accumulatedAnalysisData.size() + processedBytesRead <= MAX_ANALYSIS_BUFFER_SIZE) {
+                                accumulatedAnalysisData.write(processedChunk, 0, processedBytesRead)
                             } else {
                                 LogUtils.w(CLASS_NAME, "Analysis buffer size limit reached (${accumulatedAnalysisData.size()} bytes). Skipping data to prevent OOM.")
                             }
@@ -2521,6 +2531,23 @@ class AudioRecorderManager(
                     }
                 }
             } finally {
+                // APM retains fewer than 10 ms while completing its next frame. Preserve
+                // that raw tail on stop instead of shortening the recording or padding it.
+                val processingTail = synchronized(audioRecordLock) {
+                    softwareAudioProcessor?.flushCapture() ?: ByteArray(0)
+                }
+                if (processingTail.isNotEmpty()) {
+                    fos?.write(processingTail)
+                    if (fos != null) cachedPrimaryFileSize += processingTail.size
+                    totalDataSize += processingTail.size
+                    accumulatedAudioData?.write(processingTail)
+                    if (
+                        recordingConfig.enableProcessing &&
+                        accumulatedAnalysisData.size() + processingTail.size <= MAX_ANALYSIS_BUFFER_SIZE
+                    ) {
+                        accumulatedAnalysisData.write(processingTail)
+                    }
+                }
                 // Flush and close the file output stream if it was opened
                 try {
                     fos?.flush()
@@ -2948,6 +2975,104 @@ class AudioRecorderManager(
     private fun releaseVoiceProcessingEffects() {
         voiceProcessingEffects?.release()
         voiceProcessingEffects = null
+        softwareAudioProcessor?.release()
+        softwareAudioProcessor = null
+        audioProcessingConfigInUse = null
+        systemAudioProcessingStatus = SystemAudioProcessingStatus()
+    }
+
+    private fun configureAudioProcessing(currentSourceName: String, audioSessionId: Int) {
+        val config = recordingConfig.audioProcessing
+            ?: if (currentSourceName == "voiceCommunication") AndroidAudioProcessingConfig() else null
+        if (config == null) return
+
+        audioProcessingConfigInUse = config
+        val requested = AudioProcessingRequest.from(config)
+        if (config.mode != AndroidAudioProcessingMode.SOFTWARE && requested.anyEnabled) {
+            voiceProcessingEffects = VoiceProcessingEffects.attach(audioSessionId, requested)
+            systemAudioProcessingStatus = checkNotNull(voiceProcessingEffects).status
+        }
+        val plan = AudioProcessingPlan.create(config, systemAudioProcessingStatus)
+        softwareAudioProcessor = WebRtcAudioFrameProcessor.create(
+            sampleRate = recordingConfig.sampleRate,
+            channels = recordingConfig.channels,
+            encoding = recordingConfig.encoding,
+            request = plan.software,
+        )
+        val status = currentAudioProcessingStatus()
+        LogUtils.i(
+            CLASS_NAME,
+            "3A selected mode=${status.mode} AEC=${status.aec.wireValue} " +
+                "NS=${status.noiseSuppression.wireValue} AGC=${status.automaticGainControl.wireValue} " +
+                "reverseStreamConnected=${status.reverseStreamConnected}"
+        )
+    }
+
+    private fun currentAudioProcessingStatus(): AudioProcessingStatus {
+        val config = audioProcessingConfigInUse
+            ?: return AudioProcessingStatus.disabled(
+                sampleRate = if (::recordingConfig.isInitialized) recordingConfig.sampleRate else 0,
+                channels = if (::recordingConfig.isInitialized) recordingConfig.channels else 0,
+            )
+        val requested = AudioProcessingRequest.from(config)
+        val software = softwareAudioProcessor
+        val softwareRequest = software?.request
+        val reverseStreamConnected = software?.reverseStreamConnected == true
+
+        fun backend(
+            requestedEffect: Boolean,
+            systemEnabled: Boolean,
+            softwareEnabled: Boolean,
+        ): AudioProcessingBackend = when {
+            !requestedEffect -> AudioProcessingBackend.DISABLED
+            systemEnabled -> AudioProcessingBackend.SYSTEM
+            software != null && software.operational && softwareEnabled -> AudioProcessingBackend.WEBRTC
+            else -> AudioProcessingBackend.UNAVAILABLE
+        }
+
+        return AudioProcessingStatus(
+            mode = config.mode.wireValue,
+            aec = backend(
+                requested.echoCancellation,
+                systemAudioProcessingStatus.aec,
+                // Creating AEC3 is not evidence that echo cancellation is active.
+                // It only becomes effective after real speaker PCM reaches the reverse stream.
+                softwareRequest?.echoCancellation == true && reverseStreamConnected,
+            ),
+            noiseSuppression = backend(
+                requested.noiseSuppression,
+                systemAudioProcessingStatus.noiseSuppression,
+                softwareRequest?.noiseSuppression == true,
+            ),
+            automaticGainControl = backend(
+                requested.automaticGainControl,
+                systemAudioProcessingStatus.automaticGainControl,
+                softwareRequest?.automaticGainControl == true,
+            ),
+            reverseStreamConnected = reverseStreamConnected,
+            sampleRate = recordingConfig.sampleRate,
+            channels = recordingConfig.channels,
+        )
+    }
+
+    /**
+     * A native playback path can feed exact speaker PCM here. A JS/Base64 10 ms API is
+     * intentionally not exposed because scheduler jitter makes AEC delay unreliable.
+     */
+    internal fun processPlaybackReference(
+        pcm16: ByteArray,
+        sampleRate: Int,
+        channels: Int,
+        delayMs: Int,
+    ): Boolean = synchronized(audioRecordLock) {
+        if (
+            !::recordingConfig.isInitialized ||
+            sampleRate != recordingConfig.sampleRate ||
+            channels != recordingConfig.channels
+        ) {
+            return@synchronized false
+        }
+        softwareAudioProcessor?.processReverse(pcm16, pcm16.size, delayMs) == true
     }
 
     @RequiresApi(Build.VERSION_CODES.Q)

package/android/src/main/java/net/siteed/audiostudio/Pcm16FrameAccumulator.kt

@@ -0,0 +1,47 @@
+package net.siteed.audiostudio
+
+import java.io.ByteArrayOutputStream
+
+/** Converts arbitrary PCM16 read sizes into exact fixed-size frames without reordering data. */
+internal class Pcm16FrameAccumulator(private val frameBytes: Int) {
+    init {
+        require(frameBytes > 0 && frameBytes % 2 == 0) { "PCM16 frame size must be positive and even" }
+    }
+
+    private var pending = ByteArray(0)
+
+    @Synchronized
+    fun consume(
+        data: ByteArray,
+        length: Int,
+        transform: (ByteArray) -> ByteArray,
+    ): ByteArray {
+        require(length in 0..data.size) { "Invalid PCM byte count" }
+        if (length == 0) return ByteArray(0)
+
+        val combined = ByteArray(pending.size + length)
+        pending.copyInto(combined)
+        data.copyInto(combined, destinationOffset = pending.size, endIndex = length)
+
+        val completeBytes = combined.size - (combined.size % frameBytes)
+        if (completeBytes == 0) {
+            pending = combined
+            return ByteArray(0)
+        }
+
+        val output = ByteArrayOutputStream(completeBytes)
+        var offset = 0
+        while (offset < completeBytes) {
+            val frame = combined.copyOfRange(offset, offset + frameBytes)
+            val transformed = transform(frame)
+            require(transformed.size == frameBytes) { "PCM frame transform changed frame size" }
+            output.write(transformed)
+            offset += frameBytes
+        }
+        pending = combined.copyOfRange(completeBytes, combined.size)
+        return output.toByteArray()
+    }
+
+    @Synchronized
+    fun drain(): ByteArray = pending.also { pending = ByteArray(0) }
+}

package/android/src/main/java/net/siteed/audiostudio/RecordingConfig.kt

@@ -4,6 +4,43 @@ import android.media.AudioFormat
 import android.os.Build
 import java.io.File
 
+enum class AndroidAudioProcessingMode(val wireValue: String) {
+    SYSTEM("system"),
+    SYSTEM_WITH_SOFTWARE_FALLBACK("systemWithSoftwareFallback"),
+    SOFTWARE("software");
+
+    companion object {
+        fun fromWireValue(value: String): AndroidAudioProcessingMode =
+            entries.firstOrNull { it.wireValue == value }
+                ?: throw IllegalArgumentException(
+                    "android.audioProcessing.mode must be system, systemWithSoftwareFallback, or software"
+                )
+    }
+}
+
+data class AndroidAudioProcessingConfig(
+    val mode: AndroidAudioProcessingMode = AndroidAudioProcessingMode.SYSTEM_WITH_SOFTWARE_FALLBACK,
+    val echoCancellation: Boolean = true,
+    val noiseSuppression: Boolean = true,
+    val automaticGainControl: Boolean = true,
+) {
+    companion object {
+        fun fromValue(value: Any?): AndroidAudioProcessingConfig? {
+            if (value == null) return null
+            val map = value as? Map<*, *>
+                ?: throw IllegalArgumentException("android.audioProcessing must be an object")
+            val mode = (map["mode"] as? String)?.let(AndroidAudioProcessingMode::fromWireValue)
+                ?: AndroidAudioProcessingMode.SYSTEM_WITH_SOFTWARE_FALLBACK
+            return AndroidAudioProcessingConfig(
+                mode = mode,
+                echoCancellation = map["echoCancellation"] as? Boolean ?: true,
+                noiseSuppression = map["noiseSuppression"] as? Boolean ?: true,
+                automaticGainControl = map["automaticGainControl"] as? Boolean ?: true,
+            )
+        }
+    }
+}
+
 // New output configuration structure
 data class OutputConfig(
     val primary: PrimaryOutput = PrimaryOutput(),
@@ -67,6 +104,8 @@ data class RecordingConfig(
     val audioFocusStrategy: String? = null,
     /** Requested MediaRecorder.AudioSource: mic, voiceRecognition, voiceCommunication, unprocessed, auto. */
     val audioSource: String? = null,
+    /** Android platform 3A and WebRTC APM fallback policy. */
+    val audioProcessing: AndroidAudioProcessingConfig? = null,
     val bufferDurationSeconds: Double? = null,
     val streamFormat: String = "raw",
     val maxDurationMs: Long = 0L,
@@ -148,6 +187,11 @@ data class RecordingConfig(
             val androidConfig = options["android"] as? Map<String, Any>
             val audioFocusStrategy = androidConfig?.get("audioFocusStrategy") as? String
             val audioSource = androidConfig?.get("audioSource") as? String
+            val audioProcessing = try {
+                AndroidAudioProcessingConfig.fromValue(androidConfig?.get("audioProcessing"))
+            } catch (error: IllegalArgumentException) {
+                return Result.failure(error)
+            }
 
             // Initialize the recording configuration with cleaned directory path
             val tempRecordingConfig = RecordingConfig(
@@ -176,6 +220,7 @@ data class RecordingConfig(
                 deviceDisconnectionBehavior = deviceDisconnectionBehavior,
                 audioFocusStrategy = audioFocusStrategy,
                 audioSource = audioSource,
+                audioProcessing = audioProcessing,
                 bufferDurationSeconds = (options["bufferDurationSeconds"] as? Number)?.toDouble(),
                 streamFormat = options.getStringOrDefault("streamFormat", "raw"),
                 maxDurationMs = options.getNumberOrDefault("maxDurationMs", 0L),

package/android/src/main/java/net/siteed/audiostudio/VoiceProcessingEffects.kt

@@ -16,6 +16,7 @@ import android.media.audiofx.NoiseSuppressor
  */
 internal class VoiceProcessingEffects private constructor(
     private val effects: List<AudioEffect>,
+    val status: SystemAudioProcessingStatus,
 ) {
     fun release() {
         effects.asReversed().forEach { effect ->
@@ -30,20 +31,23 @@ internal class VoiceProcessingEffects private constructor(
     companion object {
         private const val CLASS_NAME = "VoiceProcessingEffects"
 
-        fun attach(audioSessionId: Int): VoiceProcessingEffects {
+        fun attach(
+            audioSessionId: Int,
+            request: AudioProcessingRequest = AudioProcessingRequest(true, true, true),
+        ): VoiceProcessingEffects {
             val attached = mutableListOf<AudioEffect>()
 
-            attachEffect(
+            if (request.echoCancellation) attachEffect(
                 label = "AEC",
                 available = AcousticEchoCanceler.isAvailable(),
                 create = { AcousticEchoCanceler.create(audioSessionId) },
             )?.let(attached::add)
-            attachEffect(
+            if (request.noiseSuppression) attachEffect(
                 label = "ANS",
                 available = NoiseSuppressor.isAvailable(),
                 create = { NoiseSuppressor.create(audioSessionId) },
             )?.let(attached::add)
-            attachEffect(
+            if (request.automaticGainControl) attachEffect(
                 label = "AGC",
                 available = AutomaticGainControl.isAvailable(),
                 create = { AutomaticGainControl.create(audioSessionId) },
@@ -56,7 +60,14 @@ internal class VoiceProcessingEffects private constructor(
                     "ANS=${hasType(attached, NoiseSuppressor::class.java)}, " +
                     "AGC=${hasType(attached, AutomaticGainControl::class.java)})"
             )
-            return VoiceProcessingEffects(attached)
+            return VoiceProcessingEffects(
+                effects = attached,
+                status = SystemAudioProcessingStatus(
+                    aec = hasType(attached, AcousticEchoCanceler::class.java),
+                    noiseSuppression = hasType(attached, NoiseSuppressor::class.java),
+                    automaticGainControl = hasType(attached, AutomaticGainControl::class.java),
+                )
+            )
         }
 
         private fun attachEffect(