@siteed/expo-audio-studio 2.1.1

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

@@ -0,0 +1,166 @@
+// net/siteed/audiostream/AudioAnalysisData.kt
+package net.siteed.audiostream
+
+import android.os.Bundle
+import androidx.core.os.bundleOf
+
+data class SpeechFeatures(
+    val isActive: Boolean,
+    val speakerId: Int? = null
+) {
+    fun toDictionary(): Map<String, Any?> {
+        return mapOf(
+            "isActive" to isActive,
+            "speakerId" to speakerId
+        )
+    }
+
+    fun toBundle(): Bundle {
+        return bundleOf(
+            "isActive" to isActive,
+            "speakerId" to speakerId
+        )
+    }
+}
+
+data class DataPoint(
+    val id: Long,
+    val amplitude: Float,
+    val rms: Float,
+    val dB: Float,
+    val silent: Boolean,
+    val features: Features? = null,
+    val speech: SpeechFeatures? = null,
+    val startTime: Float? = null,
+    val endTime: Float? = null,
+    val startPosition: Int? = null,
+    val endPosition: Int? = null,
+    val samples: Int = 0
+) {
+    fun toDictionary(): Map<String, Any?> {
+        return mapOf(
+            "id" to id,
+            "amplitude" to amplitude,
+            "rms" to rms,
+            "dB" to dB,
+            "silent" to silent,
+            "features" to features?.toDictionary(),
+            "speech" to speech?.toDictionary(),
+            "startTime" to startTime,
+            "endTime" to endTime,
+            "startPosition" to startPosition,
+            "endPosition" to endPosition,
+            "samples" to samples
+        )
+    }
+
+    fun toBundle(): Bundle {
+        return bundleOf(
+            "id" to id,
+            "amplitude" to amplitude,
+            "rms" to rms,
+            "dB" to dB,
+            "silent" to silent,
+            "features" to features?.toBundle(),
+            "speech" to speech?.toBundle(),
+            "startTime" to startTime,
+            "endTime" to endTime,
+            "startPosition" to startPosition,
+            "endPosition" to endPosition,
+            "samples" to samples
+        )
+    }
+}
+
+data class AudioAnalysisData(
+    val segmentDurationMs: Int,
+    val durationMs: Int,
+    val bitDepth: Int,
+    val numberOfChannels: Int,
+    val sampleRate: Int,
+    val samples: Int,
+    val dataPoints: List<DataPoint>,
+    val amplitudeRange: AmplitudeRange,
+    val rmsRange: AmplitudeRange,
+    val speechAnalysis: SpeechAnalysis? = null,
+    val extractionTimeMs: Float
+) {
+    data class AmplitudeRange(val min: Float, val max: Float) {
+        fun toDictionary(): Map<String, Float> {
+            return mapOf("min" to min, "max" to max)
+        }
+
+        fun toBundle(): Bundle {
+            return bundleOf("min" to min, "max" to max)
+        }
+    }
+
+    data class SpeechAnalysis(
+        val speakerChanges: List<SpeakerChange>
+    ) {
+        fun toDictionary(): Map<String, Any> {
+            return mapOf(
+                "speakerChanges" to speakerChanges.map { it.toDictionary() }
+            )
+        }
+
+        fun toBundle(): Bundle {
+            return bundleOf(
+                "speakerChanges" to speakerChanges.map { it.toBundle() }.toTypedArray()
+            )
+        }
+    }
+
+    data class SpeakerChange(
+        val timestamp: Long,
+        val speakerId: Int
+    ) {
+        fun toDictionary(): Map<String, Any> {
+            return mapOf(
+                "timestamp" to timestamp,
+                "speakerId" to speakerId
+            )
+        }
+
+        fun toBundle(): Bundle {
+            return bundleOf(
+                "timestamp" to timestamp,
+                "speakerId" to speakerId
+            )
+        }
+    }
+
+    fun toDictionary(): Map<String, Any?> {
+        return mapOf(
+            "segmentDurationMs" to segmentDurationMs,
+            "durationMs" to durationMs,
+            "bitDepth" to bitDepth,
+            "numberOfChannels" to numberOfChannels,
+            "sampleRate" to sampleRate,
+            "samples" to samples,
+            "dataPoints" to dataPoints.map { it.toDictionary() },
+            "amplitudeRange" to amplitudeRange.toDictionary(),
+            "rmsRange" to rmsRange.toDictionary(),
+            "speechAnalysis" to speechAnalysis?.toDictionary(),
+            "extractionTimeMs" to extractionTimeMs
+        )
+    }
+
+    fun toBundle(): Bundle {
+        val dataPointsBundleArray = dataPoints.map { it.toBundle() }.toTypedArray()
+
+        return bundleOf(
+            "segmentDurationMs" to segmentDurationMs,
+            "durationMs" to durationMs,
+            "bitDepth" to bitDepth,
+            "numberOfChannels" to numberOfChannels,
+            "sampleRate" to sampleRate,
+            "samples" to samples,
+            "dataPoints" to dataPointsBundleArray,
+            "amplitudeRange" to amplitudeRange.toBundle(),
+            "rmsRange" to rmsRange.toBundle(),
+            "speechAnalysis" to speechAnalysis?.toBundle(),
+            "extractionTimeMs" to extractionTimeMs
+        )
+    }
+}

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

@@ -0,0 +1,9 @@
+package net.siteed.audiostream
+
+import android.util.Base64
+
+class AudioDataEncoder {
+    public fun encodeToBase64(rawData: ByteArray): String {
+        return Base64.encodeToString(rawData, Base64.NO_WRAP)
+    }
+}

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

@@ -0,0 +1,131 @@
+package net.siteed.audiostream
+
+import android.util.Log
+import java.io.File
+import java.io.IOException
+import java.io.OutputStream
+import java.io.RandomAccessFile
+import java.util.UUID
+
+class AudioFileHandler(private val filesDir: File) {
+    // Method to write WAV file header
+    fun writeWavHeader(out: OutputStream, sampleRateInHz: Int, channels: Int, bitDepth: Int) {
+        val header = ByteArray(44)
+        val byteRate = sampleRateInHz * channels * bitDepth / 8
+        val blockAlign = channels * bitDepth / 8
+
+        // RIFF/WAVE header
+        "RIFF".toByteArray().copyInto(header, 0)
+        // (file size - 8) to be updated later
+        header[4] = 0 // Placeholder
+        header[5] = 0 // Placeholder
+        header[6] = 0 // Placeholder
+        header[7] = 0 // Placeholder
+        "WAVE".toByteArray().copyInto(header, 8)
+        "fmt ".toByteArray().copyInto(header, 12)
+
+        // 16 for PCM
+        header[16] = 16
+        header[17] = 0
+        header[18] = 0
+        header[19] = 0
+
+        // PCM format ID
+        header[20] = 1 // Audio format 1 for PCM (not compressed)
+        header[21] = 0
+
+        // Number of channels
+        header[22] = (channels and 0xff).toByte()
+        header[23] = (channels shr 8 and 0xff).toByte()
+
+        // Sample rate
+        header[24] = (sampleRateInHz and 0xff).toByte()
+        header[25] = (sampleRateInHz shr 8 and 0xff).toByte()
+        header[26] = (sampleRateInHz shr 16 and 0xff).toByte()
+        header[27] = (sampleRateInHz shr 24 and 0xff).toByte()
+
+        // Byte rate
+        header[28] = (byteRate and 0xff).toByte()
+        header[29] = (byteRate shr 8 and 0xff).toByte()
+        header[30] = (byteRate shr 16 and 0xff).toByte()
+        header[31] = (byteRate shr 24 and 0xff).toByte()
+
+        // Block align
+        header[32] = (blockAlign and 0xff).toByte()
+        header[33] = (blockAlign shr 8 and 0xff).toByte()
+
+        // Bits per sample
+        header[34] = (bitDepth and 0xff).toByte()
+        header[35] = (bitDepth shr 8 and 0xff).toByte()
+
+        // Data chunk
+        "data".toByteArray().copyInto(header, 36)
+        // Data size to be updated later
+        header[40] = 0 // Placeholder
+        header[41] = 0 // Placeholder
+        header[42] = 0 // Placeholder
+        header[43] = 0 // Placeholder
+
+        out.write(header, 0, 44)
+    }
+
+    fun updateWavHeader(file: File) {
+        try {
+            RandomAccessFile(file, "rw").use { raf ->
+                val fileSize = raf.length()
+                val dataSize = fileSize - 44 // Subtract the header size
+
+                raf.seek(4) // Write correct file size, excluding the first 8 bytes of the RIFF header
+                raf.writeInt(Integer.reverseBytes((dataSize + 36).toInt()))
+
+                raf.seek(40) // Go to the data size position
+                raf.writeInt(Integer.reverseBytes(dataSize.toInt())) // Write the size of the data segment
+            }
+        } catch (e: IOException) {
+            println("Could not update WAV header: ${e.message}")
+        }
+    }
+
+    fun clearAudioStorage() {
+        filesDir.listFiles()?.forEach {
+            it.delete()
+        }
+    }
+
+    fun createAudioFile(extension: String): File {
+        val timestamp = System.currentTimeMillis()
+        val uuid = UUID.randomUUID().toString()
+        val filename = "recording_${timestamp}_${uuid}.${extension}"
+        
+        return try {
+            File(filesDir, filename).apply {
+                parentFile?.mkdirs() // Create directories if they don't exist
+                createNewFile()      // Create the file
+            }
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Failed to create audio file", e)
+            throw e
+        }
+    }
+
+    fun deleteFile(file: File?): Boolean {
+        return try {
+            if (file == null) {
+                Log.w(Constants.TAG, "Attempted to delete null file")
+                false
+            } else if (!file.exists()) {
+                Log.w(Constants.TAG, "File does not exist: ${file.absolutePath}")
+                false
+            } else {
+                val wasDeleted = file.delete()
+                if (!wasDeleted) {
+                    Log.w(Constants.TAG, "Failed to delete file: ${file.absolutePath}")
+                }
+                wasDeleted
+            }
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Error deleting file: ${file?.absolutePath}", e)
+            false
+        }
+    }
+}

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

@@ -0,0 +1,103 @@
+package net.siteed.audiostream
+
+import android.media.AudioFormat
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+object AudioFormatUtils {
+    /**
+     * Converts a byte array of audio data to a float array based on the given encoding.
+     * @param audioData The raw audio data in bytes.
+     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
+     * @return A float array with normalized audio samples in the range [-1.0, 1.0].
+     */
+    fun convertByteArrayToFloatArray(audioData: ByteArray, encoding: String): FloatArray {
+        return when (encoding) {
+            "pcm_8bit" -> {
+                val floatArray = FloatArray(audioData.size)
+                for (i in audioData.indices) {
+                    // Convert unsigned 8-bit to float in range [-1.0, 1.0]
+                    floatArray[i] = ((audioData[i].toInt() and 0xFF) - 128) / 128.0f
+                }
+                floatArray
+            }
+            "pcm_16bit" -> {
+                val floatArray = FloatArray(audioData.size / 2)
+                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
+                for (i in floatArray.indices) {
+                    floatArray[i] = buffer.short / 32768.0f // Normalize to [-1.0, 1.0]
+                }
+                floatArray
+            }
+            "pcm_32bit" -> {
+                val floatArray = FloatArray(audioData.size / 4)
+                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
+                for (i in floatArray.indices) {
+                    floatArray[i] = buffer.int / 2_147_483_648.0f // Normalize to [-1.0, 1.0]
+                }
+                floatArray
+            }
+            else -> {
+                // Default to 16-bit PCM if encoding is not recognized
+                val floatArray = FloatArray(audioData.size / 2)
+                val buffer = ByteBuffer.wrap(audioData).order(ByteOrder.LITTLE_ENDIAN)
+                for (i in floatArray.indices) {
+                    floatArray[i] = buffer.short / 32768.0f
+                }
+                floatArray
+            }
+        }
+    }
+
+    /**
+     * Calculates the bit depth (number of bits per sample) based on the encoding string.
+     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
+     * @return The bit depth as an integer.
+     */
+    fun getBitDepth(encoding: String): Int {
+        return when (encoding) {
+            "pcm_8bit" -> 8
+            "pcm_16bit" -> 16
+            "pcm_32bit" -> 32
+            else -> 16 // Default to 16-bit if not recognized
+        }
+    }
+
+    /**
+     * Determines the AudioFormat encoding constant based on the encoding string.
+     * @param encoding The encoding format (e.g., "pcm_8bit", "pcm_16bit", "pcm_32bit").
+     * @return The corresponding AudioFormat constant.
+     */
+    fun getAudioFormat(encoding: String): Int {
+        return when (encoding) {
+            "pcm_8bit" -> AudioFormat.ENCODING_PCM_8BIT
+            "pcm_16bit" -> AudioFormat.ENCODING_PCM_16BIT
+            "pcm_32bit" -> AudioFormat.ENCODING_PCM_FLOAT
+            else -> AudioFormat.ENCODING_PCM_16BIT // Default to 16-bit PCM
+        }
+    }
+
+    /**
+     * Converts audio data between different bit depths
+     * @param audioData The raw audio data
+     * @param sourceBitDepth The original bit depth
+     * @param targetBitDepth The desired bit depth
+     * @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")
+        }
+    }
+}