@siteed/audio-studio 3.0.0

package/android/src/main/jni/MelSpectrogramJNI.cpp

@@ -0,0 +1,165 @@
+#include <jni.h>
+#include <android/log.h>
+#include "MelSpectrogram.h"
+#include <memory>
+#include <cmath>
+#include <mutex>
+
+#define LOG_TAG "MelSpectrogramJNI"
+#define LOGI(...) __android_log_print(ANDROID_LOG_INFO, LOG_TAG, __VA_ARGS__)
+#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR, LOG_TAG, __VA_ARGS__)
+
+// Cache processor across JNI calls — avoids rebuilding FFT plan,
+// window, and filterbank when config is unchanged.
+static std::unique_ptr<MelSpectrogramProcessor> cachedProcessor;
+static std::mutex cachedMutex;
+
+extern "C" JNIEXPORT jobjectArray JNICALL
+Java_net_siteed_audiostudio_MelSpectrogramNative_compute(
+    JNIEnv* env, jobject /* thiz */,
+    jfloatArray jSamples, jint sampleRate, jint fftLength,
+    jint windowSizeSamples, jint hopLengthSamples,
+    jint nMels, jfloat fMin, jfloat fMax,
+    jint windowType, jboolean logScale, jboolean normalize)
+{
+    jfloat* samples = env->GetFloatArrayElements(jSamples, nullptr);
+    if (!samples) {
+        LOGE("Failed to get float array elements");
+        return nullptr;
+    }
+    jint numSamples = env->GetArrayLength(jSamples);
+
+    LOGI("compute: numSamples=%d, sampleRate=%d, fftLength=%d, windowSize=%d, hop=%d, nMels=%d",
+         numSamples, sampleRate, fftLength, windowSizeSamples, hopLengthSamples, nMels);
+
+    MelSpectrogramConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.windowSizeSamples = windowSizeSamples;
+    config.hopLengthSamples = hopLengthSamples;
+    config.nMels = nMels;
+    config.fMin = fMin;
+    config.fMax = fMax;
+    config.windowType = windowType;
+    config.logScale = logScale;
+    config.normalize = normalize;
+
+    // Reuse processor if config matches
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<MelSpectrogramProcessor>(config);
+    }
+
+    MelSpectrogramResult result = cachedProcessor->compute(samples, numSamples);
+
+    env->ReleaseFloatArrayElements(jSamples, samples, JNI_ABORT);
+
+    LOGI("compute done: timeSteps=%d, nMels=%d", result.timeSteps, result.nMels);
+
+    if (result.timeSteps <= 0) {
+        return nullptr;
+    }
+
+    // Create float[][] result
+    jclass floatArrayClass = env->FindClass("[F");
+    if (!floatArrayClass) {
+        LOGE("Failed to find float[] class");
+        return nullptr;
+    }
+
+    jobjectArray jResult = env->NewObjectArray(result.timeSteps, floatArrayClass, nullptr);
+    if (!jResult) {
+        LOGE("Failed to allocate result array");
+        return nullptr;
+    }
+
+    for (int i = 0; i < result.timeSteps; ++i) {
+        jfloatArray row = env->NewFloatArray(result.nMels);
+        if (!row) {
+            LOGE("Failed to allocate row %d", i);
+            return jResult;  // Return partial result rather than leak
+        }
+        env->SetFloatArrayRegion(row, 0, result.nMels,
+                                 result.data.data() + i * result.nMels);
+        env->SetObjectArrayElement(jResult, i, row);
+        env->DeleteLocalRef(row);
+    }
+
+    return jResult;
+}
+
+extern "C" JNIEXPORT void JNICALL
+Java_net_siteed_audiostudio_MelSpectrogramNative_init(
+    JNIEnv* env, jobject /* thiz */,
+    jint sampleRate, jint fftLength, jint windowSizeSamples,
+    jint hopLengthSamples, jint nMels, jfloat fMin, jfloat fMax,
+    jint windowType)
+{
+    MelSpectrogramConfig config;
+    config.sampleRate = sampleRate;
+    config.fftLength = fftLength;
+    config.windowSizeSamples = windowSizeSamples;
+    config.hopLengthSamples = hopLengthSamples;
+    config.nMels = nMels;
+    config.fMin = fMin;
+    config.fMax = fMax;
+    config.windowType = windowType;
+    config.logScale = false;
+    config.normalize = false;
+
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor || !(cachedProcessor->config() == config)) {
+        cachedProcessor = std::make_unique<MelSpectrogramProcessor>(config);
+    }
+    LOGI("init: sampleRate=%d, fftLength=%d, nMels=%d", sampleRate, fftLength, nMels);
+}
+
+extern "C" JNIEXPORT jboolean JNICALL
+Java_net_siteed_audiostudio_MelSpectrogramNative_computeFrame(
+    JNIEnv* env, jobject /* thiz */,
+    jfloatArray jFrame, jfloatArray jMelOutput)
+{
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor) {
+        LOGE("computeFrame: processor not initialized, call init() first");
+        return JNI_FALSE;
+    }
+
+    jfloat* frame = env->GetFloatArrayElements(jFrame, nullptr);
+    if (!frame) {
+        LOGE("computeFrame: failed to get frame array");
+        return JNI_FALSE;
+    }
+    jint frameSize = env->GetArrayLength(jFrame);
+
+    jfloat* melOutput = env->GetFloatArrayElements(jMelOutput, nullptr);
+    if (!melOutput) {
+        env->ReleaseFloatArrayElements(jFrame, frame, JNI_ABORT);
+        LOGE("computeFrame: failed to get melOutput array");
+        return JNI_FALSE;
+    }
+
+    cachedProcessor->computeFrame(frame, frameSize, melOutput);
+
+    // Always apply log scaling (log(max(1e-10, val))) regardless of config.logScale
+    const int nMels = cachedProcessor->config().nMels;
+    for (int i = 0; i < nMels; ++i) {
+        melOutput[i] = std::log(std::max(1e-10f, melOutput[i]));
+    }
+
+    env->ReleaseFloatArrayElements(jFrame, frame, JNI_ABORT);
+    env->ReleaseFloatArrayElements(jMelOutput, melOutput, 0); // 0 = copy back
+
+    return JNI_TRUE;
+}
+
+extern "C" JNIEXPORT jint JNICALL
+Java_net_siteed_audiostudio_MelSpectrogramNative_getNMels(
+    JNIEnv* env, jobject /* thiz */)
+{
+    std::lock_guard<std::mutex> lock(cachedMutex);
+    if (!cachedProcessor) {
+        return 0;
+    }
+    return cachedProcessor->config().nMels;
+}

package/android/src/main/res/drawable/ic_default_action_icon.xml

@@ -0,0 +1,16 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M12,2C6.48,2 2,6.48 2,12C2,17.52 6.48,22 12,22C17.52,22 22,17.52 22,12C22,6.48 17.52,2 12,2ZM12,20C7.58,20 4,16.42 4,12C4,7.58 7.58,4 12,4C16.42,4 20,7.58 20,12C20,16.42 16.42,20 12,20Z"/>
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M12,17L12,7"/>
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M7,12L17,12"/>
+</vector>

package/android/src/main/res/drawable/ic_microphone.xml

@@ -0,0 +1,13 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M12,14c1.66,0 3,-1.34 3,-3V5c0,-1.66 -1.34,-3 -3,-3S9,3.34 9,5v6C9,12.66 10.34,14 12,14z"/>
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M17,11c0,2.76 -2.24,5 -5,5s-5,-2.24 -5,-5H5c0,3.53 2.61,6.43 6,6.92V21h2v-3.08c3.39,-0.49 6,-3.39 6,-6.92H17z"/>
+</vector>

package/android/src/main/res/drawable/ic_pause.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M6,4h4v16H6zM14,4h4v16h-4z"/>
+</vector>

package/android/src/main/res/drawable/ic_play.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M8,5v14l11,-7z"/>
+</vector>

package/android/src/main/res/drawable/ic_stop.xml

@@ -0,0 +1,10 @@
+<?xml version="1.0" encoding="utf-8"?>
+<vector xmlns:android="http://schemas.android.com/apk/res/android"
+    android:width="24dp"
+    android:height="24dp"
+    android:viewportWidth="24"
+    android:viewportHeight="24">
+    <path
+        android:fillColor="#FFFFFF"
+        android:pathData="M6,6h12v12H6z"/>
+</vector>

package/android/src/main/res/layout/notification_recording.xml

@@ -0,0 +1,37 @@
+<LinearLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    android:id="@+id/notification_layout"
+    android:layout_width="match_parent"
+    android:layout_height="wrap_content"
+    android:gravity="center"
+    android:orientation="vertical"
+    android:padding="8dp">
+
+    <TextView
+        android:id="@+id/notification_title"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="4dp"
+        android:textSize="16sp"
+        android:textStyle="bold" />
+
+    <TextView
+        android:id="@+id/notification_text"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginBottom="4dp"
+        android:textSize="14sp" />
+
+    <ImageView
+        android:id="@+id/notification_waveform"
+        android:layout_width="match_parent"
+        android:layout_height="64dp"
+        android:scaleType="fitCenter" />
+
+    <TextView
+        android:id="@+id/notification_duration"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:layout_marginTop="4dp"
+        android:textSize="14sp" />
+
+</LinearLayout>

package/android/src/test/java/net/siteed/audiostudio/AudioFileHandlerTest.kt

@@ -0,0 +1,279 @@
+package net.siteed.audiostudio
+
+import org.junit.Test
+import org.junit.Assert.*
+import org.junit.Before
+import org.junit.After
+import java.io.ByteArrayOutputStream
+import java.io.File
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+import kotlin.test.assertNotNull
+
+class AudioFileHandlerTest {
+    private lateinit var tempDir: File
+    private lateinit var audioFileHandler: AudioFileHandler
+
+    @Before
+    fun setUp() {
+        // Create a temporary directory for testing
+        tempDir = File(System.getProperty("java.io.tmpdir"), "audio_test_${System.currentTimeMillis()}")
+        tempDir.mkdirs()
+        audioFileHandler = AudioFileHandler(tempDir)
+    }
+
+    @After
+    fun tearDown() {
+        // Clean up temporary directory
+        tempDir.deleteRecursively()
+    }
+
+    @Test
+    fun testWriteWavHeader_writesCorrectHeaderFormat() {
+        // Given
+        val outputStream = ByteArrayOutputStream()
+        val sampleRate = 44100
+        val channels = 2
+        val bitDepth = 16
+
+        // When
+        audioFileHandler.writeWavHeader(outputStream, sampleRate, channels, bitDepth)
+        val header = outputStream.toByteArray()
+
+        // Then
+        assertEquals("WAV header should be 44 bytes", 44, header.size)
+        
+        // Check RIFF header
+        assertEquals("Should start with RIFF", "RIFF", String(header.sliceArray(0..3)))
+        assertEquals("Should contain WAVE identifier", "WAVE", String(header.sliceArray(8..11)))
+        assertEquals("Should contain fmt chunk", "fmt ", String(header.sliceArray(12..15)))
+        assertEquals("Should contain data chunk", "data", String(header.sliceArray(36..39)))
+        
+        // Check audio format (PCM = 1)
+        val audioFormat = ByteBuffer.wrap(header.sliceArray(20..21)).order(ByteOrder.LITTLE_ENDIAN).short
+        assertEquals("Audio format should be 1 (PCM)", 1, audioFormat.toInt())
+        
+        // Check channels
+        val headerChannels = ByteBuffer.wrap(header.sliceArray(22..23)).order(ByteOrder.LITTLE_ENDIAN).short
+        assertEquals("Channels should match", channels, headerChannels.toInt())
+        
+        // Check sample rate
+        val headerSampleRate = ByteBuffer.wrap(header.sliceArray(24..27)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("Sample rate should match", sampleRate, headerSampleRate)
+        
+        // Check bit depth
+        val headerBitDepth = ByteBuffer.wrap(header.sliceArray(34..35)).order(ByteOrder.LITTLE_ENDIAN).short
+        assertEquals("Bit depth should match", bitDepth, headerBitDepth.toInt())
+    }
+
+    @Test
+    fun testWriteWavHeader_calculatesCorrectByteRate() {
+        // Given
+        val outputStream = ByteArrayOutputStream()
+        val sampleRate = 48000
+        val channels = 1
+        val bitDepth = 24
+        val expectedByteRate = sampleRate * channels * bitDepth / 8
+
+        // When
+        audioFileHandler.writeWavHeader(outputStream, sampleRate, channels, bitDepth)
+        val header = outputStream.toByteArray()
+
+        // Then
+        val byteRate = ByteBuffer.wrap(header.sliceArray(28..31)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("Byte rate should be correctly calculated", expectedByteRate, byteRate)
+    }
+
+    @Test
+    fun testCreateAudioFile_createsFileWithCorrectExtension() {
+        // Given
+        val extension = "wav"
+
+        // When
+        val file = audioFileHandler.createAudioFile(extension)
+
+        // Then
+        assertNotNull("File should not be null", file)
+        assertTrue("File should exist", file.exists())
+        assertTrue("File should have correct extension", file.name.endsWith(".$extension"))
+        assertTrue("File should have correct prefix", file.name.startsWith("recording_"))
+        
+        // Clean up
+        file.delete()
+    }
+
+    @Test
+    fun testCreateAudioFile_createsUniqueFiles() {
+        // Given
+        val extension = "wav"
+
+        // When
+        val file1 = audioFileHandler.createAudioFile(extension)
+        Thread.sleep(10) // Small delay to ensure different timestamps
+        val file2 = audioFileHandler.createAudioFile(extension)
+
+        // Then
+        assertNotEquals("Files should have unique names", file1.name, file2.name)
+        assertTrue("First file should exist", file1.exists())
+        assertTrue("Second file should exist", file2.exists())
+        
+        // Clean up
+        file1.delete()
+        file2.delete()
+    }
+
+    @Test
+    fun testDeleteFile_deletesExistingFile() {
+        // Given
+        val file = audioFileHandler.createAudioFile("wav")
+        assertTrue("File should exist before deletion", file.exists())
+
+        // When
+        val result = audioFileHandler.deleteFile(file)
+
+        // Then
+        assertTrue("Delete should return true", result)
+        assertFalse("File should not exist after deletion", file.exists())
+    }
+
+    @Test
+    fun testDeleteFile_handlesNullFile() {
+        // When
+        val result = audioFileHandler.deleteFile(null)
+
+        // Then
+        assertFalse("Delete should return false for null file", result)
+    }
+
+    @Test
+    fun testDeleteFile_handlesNonExistentFile() {
+        // Given
+        val nonExistentFile = File(tempDir, "non_existent.wav")
+        assertFalse("File should not exist", nonExistentFile.exists())
+
+        // When
+        val result = audioFileHandler.deleteFile(nonExistentFile)
+
+        // Then
+        assertFalse("Delete should return false for non-existent file", result)
+    }
+
+    @Test
+    fun testClearAudioStorage_deletesAllFiles() {
+        // Given
+        val file1 = audioFileHandler.createAudioFile("wav")
+        val file2 = audioFileHandler.createAudioFile("mp3")
+        val file3 = audioFileHandler.createAudioFile("aac")
+        
+        assertTrue("File 1 should exist", file1.exists())
+        assertTrue("File 2 should exist", file2.exists())
+        assertTrue("File 3 should exist", file3.exists())
+
+        // When
+        audioFileHandler.clearAudioStorage()
+
+        // Then
+        assertFalse("File 1 should be deleted", file1.exists())
+        assertFalse("File 2 should be deleted", file2.exists())
+        assertFalse("File 3 should be deleted", file3.exists())
+        assertEquals("Directory should be empty", 0, tempDir.listFiles()?.size ?: 0)
+    }
+
+    @Test
+    fun testUpdateWavHeader_updatesFileSizeCorrectly() {
+        // Given
+        val file = audioFileHandler.createAudioFile("wav")
+        val outputStream = file.outputStream()
+        
+        // Write header
+        audioFileHandler.writeWavHeader(outputStream, 44100, 2, 16)
+        
+        // Write some audio data (1 second of silence)
+        val audioDataSize = 44100 * 2 * 2 // sampleRate * channels * bytesPerSample
+        val audioData = ByteArray(audioDataSize)
+        outputStream.write(audioData)
+        outputStream.close()
+
+        // When
+        audioFileHandler.updateWavHeader(file)
+
+        // Then
+        val updatedHeader = file.inputStream().use { it.readNBytes(44) }
+        
+        // Check file size field (bytes 4-7)
+        val fileSize = ByteBuffer.wrap(updatedHeader.sliceArray(4..7)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("File size should be data size + 36", audioDataSize + 36, fileSize)
+        
+        // Check data size field (bytes 40-43)
+        val dataSize = ByteBuffer.wrap(updatedHeader.sliceArray(40..43)).order(ByteOrder.LITTLE_ENDIAN).int
+        assertEquals("Data size should match audio data size", audioDataSize, dataSize)
+        
+        // Clean up
+        file.delete()
+    }
+
+    @Test
+    fun testLoadRealWavFile_readsHeaderCorrectly() {
+        // Given - Load a real WAV file from test resources
+        val resourceStream = javaClass.classLoader?.getResourceAsStream("jfk.wav")
+        assertNotNull("Test resource jfk.wav should exist", resourceStream)
+        
+        val testFile = File(tempDir, "test_jfk.wav")
+        resourceStream?.use { input ->
+            testFile.outputStream().use { output ->
+                input.copyTo(output)
+            }
+        }
+        
+        // When - Read the WAV header
+        val header = testFile.inputStream().use { it.readNBytes(44) }
+        
+        // Then - Validate header structure
+        assertEquals("Should start with RIFF", "RIFF", String(header.sliceArray(0..3)))
+        assertEquals("Should contain WAVE identifier", "WAVE", String(header.sliceArray(8..11)))
+        assertEquals("Should contain fmt chunk", "fmt ", String(header.sliceArray(12..15)))
+        
+        // Extract audio properties
+        val channels = ByteBuffer.wrap(header.sliceArray(22..23)).order(ByteOrder.LITTLE_ENDIAN).short
+        val sampleRate = ByteBuffer.wrap(header.sliceArray(24..27)).order(ByteOrder.LITTLE_ENDIAN).int
+        val bitDepth = ByteBuffer.wrap(header.sliceArray(34..35)).order(ByteOrder.LITTLE_ENDIAN).short
+        
+        // JFK.wav is known to be mono, 16kHz, 16-bit
+        assertEquals("JFK audio should be mono", 1, channels.toInt())
+        assertEquals("JFK audio should be 16kHz", 16000, sampleRate)
+        assertEquals("JFK audio should be 16-bit", 16, bitDepth.toInt())
+        
+        // Clean up
+        testFile.delete()
+    }
+
+    @Test
+    fun testProcessMultipleRealWavFiles() {
+        // Test with different real WAV files to ensure compatibility
+        val testFiles = listOf("jfk.wav", "recorder_hello_world.wav", "osr_us_000_0010_8k.wav")
+        
+        for (fileName in testFiles) {
+            val resourceStream = javaClass.classLoader?.getResourceAsStream(fileName)
+            if (resourceStream != null) {
+                val testFile = File(tempDir, "test_$fileName")
+                resourceStream.use { input ->
+                    testFile.outputStream().use { output ->
+                        input.copyTo(output)
+                    }
+                }
+                
+                // Verify file was created and has content
+                assertTrue("$fileName should exist", testFile.exists())
+                assertTrue("$fileName should have more than just header", testFile.length() > 44)
+                
+                // Read and validate header
+                val header = testFile.inputStream().use { it.readNBytes(44) }
+                assertEquals("$fileName should have RIFF header", "RIFF", String(header.sliceArray(0..3)))
+                assertEquals("$fileName should have WAVE format", "WAVE", String(header.sliceArray(8..11)))
+                
+                // Clean up
+                testFile.delete()
+            }
+        }
+    }
+}