@siteed/audio-studio 3.0.0

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

@@ -0,0 +1,26 @@
+package net.siteed.audiostudio
+
+object AudioFeaturesNative {
+    init {
+        System.loadLibrary("audio-studio-cpp")
+    }
+
+    external fun computeFrame(
+        samples: FloatArray,
+        sampleRate: Int,
+        fftLength: Int,
+        nMfcc: Int,
+        nMelFilters: Int,
+        computeMfcc: Boolean,
+        computeChroma: Boolean
+    ): HashMap<String, Any>
+
+    external fun init(
+        sampleRate: Int,
+        fftLength: Int,
+        nMfcc: Int,
+        nMelFilters: Int,
+        computeMfcc: Boolean,
+        computeChroma: Boolean
+    )
+}

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

@@ -0,0 +1,136 @@
+package net.siteed.audiostudio
+
+import android.util.Log
+import java.io.File
+import java.io.IOException
+import java.io.OutputStream
+import java.io.RandomAccessFile
+import java.util.UUID
+import net.siteed.audiostudio.LogUtils
+
+class AudioFileHandler(private val filesDir: File) {
+    companion object {
+        private const val CLASS_NAME = "AudioFileHandler"
+    }
+    
+    // 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) {
+            LogUtils.e(CLASS_NAME, "Failed to create audio file", e)
+            throw e
+        }
+    }
+
+    fun deleteFile(file: File?): Boolean {
+        return try {
+            if (file == null) {
+                LogUtils.w(CLASS_NAME, "Attempted to delete null file")
+                false
+            } else if (!file.exists()) {
+                LogUtils.w(CLASS_NAME, "File does not exist: ${file.absolutePath}")
+                false
+            } else {
+                val wasDeleted = file.delete()
+                if (!wasDeleted) {
+                    LogUtils.w(CLASS_NAME, "Failed to delete file: ${file.absolutePath}")
+                }
+                wasDeleted
+            }
+        } catch (e: Exception) {
+            LogUtils.e(CLASS_NAME, "Error deleting file: ${file?.absolutePath}", e)
+            false
+        }
+    }
+}

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

@@ -0,0 +1,354 @@
+package net.siteed.audiostudio
+
+import android.media.AudioFormat
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.math.*
+
+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 {
+        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
+    }
+}