@siteed/expo-audio-studio 2.9.0 → 2.10.0

package/android/src/androidTest/java/net/siteed/audiostream/integration/README.md

@@ -0,0 +1,95 @@
+# Android Integration Tests
+
+## Overview
+
+This directory contains integration tests for the Buffer Duration and Skip File Writing features in expo-audio-studio. These tests validate ACTUAL Android platform behavior, not mocked behavior.
+
+## Test Structure
+
+### BufferDurationIntegrationTest
+Tests the actual behavior of Android AudioRecord with different buffer sizes:
+- Default buffer size handling
+- Custom buffer sizes (10ms to 500ms)
+- Buffer size limits (very small and very large)
+- Buffer accumulation for small durations
+- Different sample rates
+
+### SkipFileWritingIntegrationTest
+Tests the skip file writing feature:
+- Normal recording baseline
+- Skip file writing mode
+- Data emission without file I/O
+- Compression behavior with skip mode
+- Pause/Resume functionality
+- Memory-only operation
+
+## Running the Tests
+
+### Prerequisites
+1. Android device or emulator connected
+2. USB debugging enabled
+3. Playground app built at least once
+
+### Run All Integration Tests
+```bash
+cd packages/expo-audio-studio
+./android/src/androidTest/java/net/siteed/audiostream/integration/run_integration_tests.sh
+```
+
+### Run Individual Tests
+```bash
+cd apps/playground/android
+
+# Buffer Duration Test
+./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.BufferDurationIntegrationTest"
+
+# Skip File Writing Test
+./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.SkipFileWritingIntegrationTest"
+```
+
+## Key Findings
+
+### Android Buffer Behavior
+- Android uses `AudioRecord.getMinBufferSize()` to determine minimum buffer
+- Minimum buffer size varies by device and sample rate
+- Unlike iOS, Android respects smaller buffer requests (with accumulation)
+- No hard-coded minimum like iOS's 4800 frames
+
+### Platform Differences from iOS
+| Feature | iOS | Android |
+|---------|-----|---------|
+| Minimum Buffer | ~4800 frames (0.1s @ 48kHz) | Device-dependent |
+| Buffer Flexibility | Rigid enforcement | More flexible |
+| Small Buffer Handling | Ignored | Requires accumulation |
+| API | AVAudioEngine | AudioRecord |
+
+## Test Results Location
+- HTML Report: `android/build/reports/androidTests/connected/index.html`
+- XML Report: `android/build/test-results/androidTests/connected/`
+
+## Implementation Notes
+
+### Buffer Duration
+When implementing buffer duration on Android:
+1. Calculate buffer size: `frames * bytesPerSample * channels`
+2. Check against `AudioRecord.getMinBufferSize()`
+3. Use the larger of requested vs minimum
+4. For small buffers, implement accumulation strategy
+
+### Skip File Writing
+When implementing skip file writing:
+1. Conditionally create file based on flag
+2. Continue audio data emission without file I/O
+3. Skip compression processing when enabled
+4. Maintain pause/resume functionality
+5. Track statistics without file writing
+
+## Next Steps
+
+After these tests pass:
+1. Implement `bufferDurationSeconds` in RecordingConfig
+2. Implement `skipFileWriting` in RecordingConfig
+3. Update AudioRecorderManager to handle dynamic buffer sizing
+4. Update file creation/writing logic for skip mode
+5. Run integration tests to validate implementation
+6. Update playground app with new controls 

package/android/src/androidTest/java/net/siteed/audiostream/integration/run_integration_tests.sh

@@ -0,0 +1,28 @@
+#!/bin/bash
+
+# Android Integration Tests for Buffer Duration & Skip File Writing
+# Run this script from the expo-audio-studio package root
+
+echo "🚀 Running Android Integration Tests"
+echo "===================================="
+echo ""
+
+# Navigate to playground app (which has the gradle wrapper)
+cd ../../../apps/playground/android || exit 1
+
+echo "📱 Running Buffer Duration Integration Test..."
+echo "--------------------------------------------"
+./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.BufferDurationIntegrationTest"
+
+echo ""
+echo "📱 Running Skip File Writing Integration Test..."
+echo "-----------------------------------------------"
+./gradlew :siteed-expo-audio-studio:connectedAndroidTest --tests "*.SkipFileWritingIntegrationTest"
+
+echo ""
+echo "📊 Test Results Summary"
+echo "======================"
+echo "Check the test reports at:"
+echo "packages/expo-audio-studio/android/build/reports/androidTests/connected/index.html"
+echo ""
+echo "✅ Integration tests completed!" 

package/android/src/main/java/net/siteed/audiostream/AudioFormatUtils.kt

@@ -3,6 +3,7 @@ package net.siteed.audiostream
 import android.media.AudioFormat
 import java.nio.ByteBuffer
 import java.nio.ByteOrder
+import kotlin.math.*
 
 object AudioFormatUtils {
     /**
@@ -85,19 +86,269 @@ object AudioFormatUtils {
      * @return The converted audio data
      */
     fun convertBitDepth(audioData: ByteArray, sourceBitDepth: Int, targetBitDepth: Int): ByteArray {
-        // First convert to float array for normalization
-        val floatArray = convertByteArrayToFloatArray(audioData, "pcm_${sourceBitDepth}bit")
-        
-        // Convert back to bytes with new bit depth
-        return when (targetBitDepth) {
-            8 -> floatArray.map { ((it + 1.0f) * 127.5f).toInt().toByte() }.toByteArray()
-            16 -> ByteBuffer.allocate(floatArray.size * 2).order(ByteOrder.LITTLE_ENDIAN).apply {
-                floatArray.forEach { asShortBuffer().put((it * 32767f).toInt().toShort()) }
-            }.array()
-            32 -> ByteBuffer.allocate(floatArray.size * 4).order(ByteOrder.LITTLE_ENDIAN).apply {
-                floatArray.forEach { putFloat(it) }
-            }.array()
-            else -> throw IllegalArgumentException("Unsupported target bit depth: $targetBitDepth")
+        if (sourceBitDepth == targetBitDepth || audioData.isEmpty()) {
+            return audioData
         }
+        
+        return when {
+            sourceBitDepth == 8 && targetBitDepth == 16 -> convert8to16(audioData)
+            sourceBitDepth == 16 && targetBitDepth == 8 -> convert16to8(audioData)
+            sourceBitDepth == 16 && targetBitDepth == 32 -> convert16to32(audioData)
+            sourceBitDepth == 32 && targetBitDepth == 16 -> convert32to16(audioData)
+            sourceBitDepth == 8 && targetBitDepth == 32 -> {
+                // Convert 8 -> 16 -> 32
+                val temp16 = convert8to16(audioData)
+                convert16to32(temp16)
+            }
+            sourceBitDepth == 32 && targetBitDepth == 8 -> {
+                // Convert 32 -> 16 -> 8
+                val temp16 = convert32to16(audioData)
+                convert16to8(temp16)
+            }
+            else -> throw IllegalArgumentException("Unsupported bit depth conversion: $sourceBitDepth to $targetBitDepth")
+        }
+    }
+    
+    private fun convert8to16(data: ByteArray): ByteArray {
+        val output = ByteBuffer.allocate(data.size * 2).order(ByteOrder.LITTLE_ENDIAN)
+        for (sample in data) {
+            // Convert unsigned 8-bit (0-255) to signed 16-bit (-32768 to 32767)
+            val unsigned = sample.toInt() and 0xFF
+            // Map [0, 255] to [-32768, 32767]
+            // Special case for 0 to map to -32768
+            val signed16 = when (unsigned) {
+                0 -> -32768
+                255 -> 32767
+                else -> {
+                    val normalized = (unsigned - 128) / 128.0f
+                    (normalized * 32768).toInt().coerceIn(-32768, 32767)
+                }
+            }.toShort()
+            output.putShort(signed16)
+        }
+        return output.array()
+    }
+    
+    private fun convert16to8(data: ByteArray): ByteArray {
+        val input = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+        val output = ByteArray(data.size / 2)
+        
+        for (i in output.indices) {
+            // Convert signed 16-bit to unsigned 8-bit
+            val sample16 = input.getShort()
+            // Map [-32768, 32767] to [0, 255]
+            val normalized = sample16 / 32768.0f
+            val sample8 = ((normalized * 128) + 128).toInt().coerceIn(0, 255).toByte()
+            output[i] = sample8
+        }
+        return output
+    }
+    
+    private fun convert16to32(data: ByteArray): ByteArray {
+        val input = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+        val output = ByteBuffer.allocate(data.size * 2).order(ByteOrder.LITTLE_ENDIAN)
+        
+        while (input.hasRemaining()) {
+            val sample16 = input.getShort()
+            // Scale 16-bit to 32-bit range
+            val sample32 = (sample16.toInt() shl 16)
+            output.putInt(sample32)
+        }
+        return output.array()
+    }
+    
+    private fun convert32to16(data: ByteArray): ByteArray {
+        val input = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+        val output = ByteBuffer.allocate(data.size / 2).order(ByteOrder.LITTLE_ENDIAN)
+        
+        while (input.hasRemaining()) {
+            val sample32 = input.getInt()
+            // Scale 32-bit to 16-bit range
+            val sample16 = (sample32 shr 16).toShort()
+            output.putShort(sample16)
+        }
+        return output.array()
+    }
+
+    /**
+     * Convert between different channel configurations
+     */
+    fun convertChannels(data: ByteArray, fromChannels: Int, toChannels: Int, bitDepth: Int): ByteArray {
+        if (fromChannels == toChannels || data.isEmpty()) {
+            return data
+        }
+        
+        val bytesPerSample = bitDepth / 8
+        val samplesPerFrame = fromChannels
+        val totalFrames = data.size / (bytesPerSample * samplesPerFrame)
+        
+        return when {
+            fromChannels == 1 && toChannels == 2 -> monoToStereo(data, bitDepth, totalFrames)
+            fromChannels == 2 && toChannels == 1 -> stereoToMono(data, bitDepth, totalFrames)
+            else -> throw IllegalArgumentException("Unsupported channel conversion: $fromChannels to $toChannels")
+        }
+    }
+    
+    private fun monoToStereo(data: ByteArray, bitDepth: Int, totalFrames: Int): ByteArray {
+        val bytesPerSample = bitDepth / 8
+        val output = ByteBuffer.allocate(data.size * 2).order(ByteOrder.LITTLE_ENDIAN)
+        val input = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+        
+        for (i in 0 until totalFrames) {
+            when (bitDepth) {
+                16 -> {
+                    val sample = input.getShort()
+                    output.putShort(sample) // Left
+                    output.putShort(sample) // Right
+                }
+                32 -> {
+                    val sample = input.getInt()
+                    output.putInt(sample) // Left
+                    output.putInt(sample) // Right
+                }
+                8 -> {
+                    val sample = input.get()
+                    output.put(sample) // Left
+                    output.put(sample) // Right
+                }
+            }
+        }
+        return output.array()
+    }
+    
+    private fun stereoToMono(data: ByteArray, bitDepth: Int, totalFrames: Int): ByteArray {
+        val bytesPerSample = bitDepth / 8
+        val output = ByteBuffer.allocate(data.size / 2).order(ByteOrder.LITTLE_ENDIAN)
+        val input = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+        
+        for (i in 0 until totalFrames) {
+            when (bitDepth) {
+                16 -> {
+                    val left = input.getShort()
+                    val right = input.getShort()
+                    val mono = ((left + right) / 2).toShort()
+                    output.putShort(mono)
+                }
+                32 -> {
+                    val left = input.getInt()
+                    val right = input.getInt()
+                    val mono = ((left.toLong() + right.toLong()) / 2).toInt()
+                    output.putInt(mono)
+                }
+                8 -> {
+                    val left = input.get().toInt() and 0xFF
+                    val right = input.get().toInt() and 0xFF
+                    val mono = ((left + right) / 2).toByte()
+                    output.put(mono)
+                }
+            }
+        }
+        return output.array()
+    }
+    
+    /**
+     * Normalize audio to maximum amplitude
+     */
+    fun normalizeAudio(data: ByteArray, bitDepth: Int): ByteArray {
+        if (data.isEmpty()) return data
+        
+        val input = ByteBuffer.wrap(data).order(ByteOrder.LITTLE_ENDIAN)
+        var maxAmplitude = 0
+        
+        // Find maximum amplitude
+        input.rewind()
+        when (bitDepth) {
+            16 -> {
+                while (input.hasRemaining()) {
+                    val sample = abs(input.getShort().toInt())
+                    maxAmplitude = maxOf(maxAmplitude, sample)
+                }
+            }
+            32 -> {
+                while (input.hasRemaining()) {
+                    val sample = abs(input.getInt())
+                    maxAmplitude = maxOf(maxAmplitude, sample)
+                }
+            }
+            8 -> {
+                while (input.hasRemaining()) {
+                    val sample = abs((input.get().toInt() and 0xFF) - 128)
+                    maxAmplitude = maxOf(maxAmplitude, sample)
+                }
+            }
+        }
+        
+        // If already at max or silent, return as is
+        if (maxAmplitude == 0) return data
+        
+        val maxValue = when (bitDepth) {
+            16 -> Short.MAX_VALUE.toInt()
+            32 -> Int.MAX_VALUE
+            8 -> 127
+            else -> throw IllegalArgumentException("Unsupported bit depth: $bitDepth")
+        }
+        
+        if (maxAmplitude >= maxValue) return data
+        
+        // Normalize
+        val scaleFactor = maxValue.toFloat() / maxAmplitude
+        val output = ByteBuffer.allocate(data.size).order(ByteOrder.LITTLE_ENDIAN)
+        input.rewind()
+        
+        when (bitDepth) {
+            16 -> {
+                while (input.hasRemaining()) {
+                    val sample = input.getShort()
+                    val normalized = (sample * scaleFactor).toInt().coerceIn(-32768, 32767).toShort()
+                    output.putShort(normalized)
+                }
+            }
+            32 -> {
+                while (input.hasRemaining()) {
+                    val sample = input.getInt()
+                    val normalized = (sample * scaleFactor).toLong().coerceIn(Int.MIN_VALUE.toLong(), Int.MAX_VALUE.toLong()).toInt()
+                    output.putInt(normalized)
+                }
+            }
+            8 -> {
+                while (input.hasRemaining()) {
+                    val sample = (input.get().toInt() and 0xFF) - 128
+                    val normalized = ((sample * scaleFactor).toInt() + 128).coerceIn(0, 255).toByte()
+                    output.put(normalized)
+                }
+            }
+        }
+        
+        return output.array()
+    }
+    
+    /**
+     * Resample audio data to a different sample rate
+     */
+    fun resampleAudio(samples: FloatArray, fromSampleRate: Int, toSampleRate: Int): FloatArray {
+        if (fromSampleRate == toSampleRate || samples.isEmpty()) {
+            return samples
+        }
+        
+        val resampleRatio = toSampleRate.toDouble() / fromSampleRate
+        val newLength = (samples.size * resampleRatio).toInt()
+        val resampled = FloatArray(newLength)
+        
+        for (i in resampled.indices) {
+            val sourceIndex = i / resampleRatio
+            val sourceIndexInt = sourceIndex.toInt()
+            val fraction = sourceIndex - sourceIndexInt
+            
+            if (sourceIndexInt >= samples.size - 1) {
+                resampled[i] = samples.last()
+            } else {
+                // Linear interpolation
+                val sample1 = samples[sourceIndexInt]
+                val sample2 = samples[sourceIndexInt + 1]
+                resampled[i] = (sample1 * (1 - fraction) + sample2 * fraction).toFloat()
+            }
+        }
+        
+        return resampled
     }
 }

package/android/src/main/java/net/siteed/audiostream/AudioProcessor.kt

@@ -1059,19 +1059,9 @@ class AudioProcessor(private val filesDir: File) {
     }
 
     private fun convertChannels(pcmData: ByteArray, originalChannels: Int, targetChannels: Int): ByteArray {
-        val result = ByteArray(pcmData.size * targetChannels / originalChannels)
-        val inputBuffer = ByteBuffer.wrap(pcmData).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer()
-        val outputBuffer = ByteBuffer.wrap(result).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer()
-
-        for (i in result.indices) {
-            val channelData = ShortArray(targetChannels)
-            for (j in 0 until targetChannels) {
-                channelData[j] = inputBuffer.get()
-            }
-            outputBuffer.put(channelData)
-        }
-
-        return result
+        // Use the correct implementation from AudioFormatUtils
+        // Assuming 16-bit audio (which is the default for most audio processing)
+        return AudioFormatUtils.convertChannels(pcmData, originalChannels, targetChannels, 16)
     }
 
     private fun debugWavHeader(file: File) {