Merge pull request #109 from teamclouday/android-f32

Enable android f32 audio recording

Author: teamclouday

Android/app/src/main/java/io/github/teamclouday/AndroidMic/domain/audio/MicAudioManager.kt

@@ -16,6 +16,8 @@ import kotlinx.coroutines.delay
 import kotlinx.coroutines.flow.Flow
 import kotlinx.coroutines.flow.channelFlow
 import kotlinx.coroutines.launch
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
 
 // manage microphone recording
 class MicAudioManager(
@@ -35,6 +37,8 @@ class MicAudioManager(
     private val recorder: AudioRecord
     private val bufferSize: Int
     private val buffer: ByteArray
+    private val bufferFloat: FloatArray
+    private val bufferFloatConvert: ByteBuffer
     private var streamJob: Job? = null
 
     init {
@@ -79,6 +83,8 @@ class MicAudioManager(
         }
 
         buffer = ByteArray(bufferSize)
+        bufferFloat = FloatArray(bufferSize / 4) // float is 4 bytes
+        bufferFloatConvert = ByteBuffer.allocate(bufferSize).order(ByteOrder.nativeOrder())
     }
 
     // audio stream publisher
@@ -90,17 +96,37 @@ class MicAudioManager(
                     delay(RECORD_DELAY_MS)
                     continue
                 }
-                val bytesRead = recorder.read(buffer, 0, buffer.size)
 
-                if (bytesRead <= 0) {
+                val readCount: Int // number of samples read (for float) or number of bytes read (for int)
+                val packetBuffer: ByteArray
+
+                if (audioFormat == AudioFormat.ENCODING_PCM_FLOAT) {
+                    readCount =
+                        recorder.read(bufferFloat, 0, bufferFloat.size, AudioRecord.READ_BLOCKING)
+
+                    if (readCount > 0) {
+                        bufferFloatConvert.clear()
+                        bufferFloatConvert.asFloatBuffer().put(bufferFloat, 0, readCount)
+                        packetBuffer = bufferFloatConvert.array()
+                    } else {
+                        packetBuffer = ByteArray(0)
+                    }
+                } else {
+                    readCount = recorder.read(buffer, 0, buffer.size)
+
+                    if (readCount > 0) {
+                        packetBuffer = ByteArray(readCount)
+                        buffer.copyInto(packetBuffer, 0, 0, readCount)
+                    } else {
+                        packetBuffer = ByteArray(0)
+                    }
+                }
+
+                if (readCount <= 0) {
                     delay(RECORD_DELAY_MS)
                     continue
                 }
 
-//                Log.d(TAG, "audioStream: $bytesRead bytes read")
-
-                val packetBuffer = ByteArray(bytesRead)
-                buffer.copyInto(packetBuffer, 0, 0, bytesRead)
                 send(
                     AudioPacket(
                         buffer = packetBuffer,

RustApp/src/streamer/mod.rs

@@ -156,8 +156,9 @@ impl StreamerTrait for DummyStreamer {
 }
 
 impl AudioPacketMessage {
-    fn to_wave_data(buffer: &[f32]) -> Vec<(f32, f32)> {
-        let window_size = 50;
+    fn to_wave_data(buffer: &[f32], sample_rate: u32) -> Vec<(f32, f32)> {
+        const DEFAULT_WINDOW_DURATION_MS: f32 = 10.0; // 10ms window
+        let window_size = ((sample_rate as f32 * DEFAULT_WINDOW_DURATION_MS) / 1000.0) as usize;
 
         buffer
             .chunks_exact(window_size)

RustApp/src/streamer/tcp_streamer.rs

@@ -113,12 +113,16 @@ impl StreamerTrait for TcpStreamer {
                         match AudioPacketMessage::decode(frame) {
                             Ok(packet) => {
                                 let buffer_size = packet.buffer.len();
+                                let sample_rate = packet.sample_rate;
 
                                 if let Ok(buffer) = self.stream_config.process_audio_packet(packet)
                                 {
                                     // compute the audio wave from the buffer
                                     res = Some(StreamerMsg::UpdateAudioWave {
-                                        data: AudioPacketMessage::to_wave_data(&buffer),
+                                        data: AudioPacketMessage::to_wave_data(
+                                            &buffer,
+                                            sample_rate,
+                                        ),
                                     });
 
                                     debug!("received {} bytes", buffer_size);

RustApp/src/streamer/udp_streamer.rs

@@ -83,11 +83,12 @@ impl StreamerTrait for UdpStreamer {
 
                         let packet = packet.audio_packet.unwrap();
                         let buffer_size = packet.buffer.len();
+                        let sample_rate = packet.sample_rate;
 
                         if let Ok(buffer) = self.stream_config.process_audio_packet(packet) {
                             // compute the audio wave from the buffer
                             res = Some(StreamerMsg::UpdateAudioWave {
-                                data: AudioPacketMessage::to_wave_data(&buffer),
+                                data: AudioPacketMessage::to_wave_data(&buffer, sample_rate),
                             });
 
                             debug!("From {:?}, received {} bytes", addr, buffer_size);

RustApp/src/streamer/usb_streamer.rs

@@ -198,11 +198,12 @@ impl StreamerTrait for UsbStreamer {
                 match AudioPacketMessage::decode(frame) {
                     Ok(packet) => {
                         let buffer_size = packet.buffer.len();
+                        let sample_rate = packet.sample_rate;
 
                         if let Ok(buffer) = self.stream_config.process_audio_packet(packet) {
                             // compute the audio wave from the buffer
                             res = Some(StreamerMsg::UpdateAudioWave {
-                                data: AudioPacketMessage::to_wave_data(&buffer),
+                                data: AudioPacketMessage::to_wave_data(&buffer, sample_rate),
                             });
 
                             debug!("received {} bytes", buffer_size);