@siteed/audio-studio 3.1.1 → 3.2.0

package/src/utils/audioProcessing.ts

@@ -6,8 +6,8 @@ import { ConsoleLike } from '../AudioStudio.types'
 export interface ProcessAudioBufferOptions {
     arrayBuffer?: ArrayBuffer
     fileUri?: string
-    targetSampleRate: number
-    targetChannels: number
+    targetSampleRate?: number
+    targetChannels?: number
     normalizeAudio: boolean
     startTimeMs?: number
     endTimeMs?: number
@@ -84,9 +84,17 @@ export async function processAudioBuffer({
         // Create context at original sample rate first
         ctx =
             audioContext ||
-            new (window.AudioContext || (window as any).webkitAudioContext)()
+            new (window.AudioContext ||
+                (
+                    window as unknown as {
+                        webkitAudioContext?: typeof AudioContext
+                    }
+                ).webkitAudioContext)()
         buffer = await ctx.decodeAudioData(audioData)
 
+        const effectiveTargetSampleRate = targetSampleRate ?? buffer.sampleRate
+        const effectiveTargetChannels = targetChannels ?? buffer.numberOfChannels
+
         logger?.debug('Decoded audio buffer:', {
             originalChannels: buffer.numberOfChannels,
             originalSampleRate: buffer.sampleRate,
@@ -109,7 +117,7 @@ export async function processAudioBuffer({
             position !== undefined
                 ? Math.floor(
                       (position / bytesPerSample) *
-                          (buffer.sampleRate / targetSampleRate)
+                          (buffer.sampleRate / effectiveTargetSampleRate)
                   )
                 : startSample
 
@@ -117,11 +125,12 @@ export async function processAudioBuffer({
             length !== undefined
                 ? Math.floor(
                       (length / bytesPerSample) *
-                          (buffer.sampleRate / targetSampleRate)
+                          (buffer.sampleRate / effectiveTargetSampleRate)
                   )
-                : endTimeMs !== undefined && startTimeMs !== undefined
+                : endTimeMs !== undefined
                   ? Math.floor(
-                        ((endTimeMs - startTimeMs) / 1000) * buffer.sampleRate
+                        ((endTimeMs - (startTimeMs ?? 0)) / 1000) *
+                            buffer.sampleRate
                     )
                   : buffer.length - adjustedStartSample
 
@@ -130,8 +139,8 @@ export async function processAudioBuffer({
             adjustedStartSample,
             samplesNeeded,
             originalSampleRate: buffer.sampleRate,
-            targetSampleRate,
-            conversionRatio: buffer.sampleRate / targetSampleRate,
+            targetSampleRate: effectiveTargetSampleRate,
+            conversionRatio: buffer.sampleRate / effectiveTargetSampleRate,
             expectedDurationMs: (samplesNeeded / buffer.sampleRate) * 1000,
         })
 
@@ -153,9 +162,11 @@ export async function processAudioBuffer({
 
         // Create offline context for resampling
         const offlineCtx = new OfflineAudioContext(
-            targetChannels,
-            Math.ceil((samplesNeeded * targetSampleRate) / buffer.sampleRate),
-            targetSampleRate
+            effectiveTargetChannels,
+            Math.ceil(
+                (samplesNeeded * effectiveTargetSampleRate) / buffer.sampleRate
+            ),
+            effectiveTargetSampleRate
         )
 
         // Create source and connect
@@ -175,7 +186,7 @@ export async function processAudioBuffer({
 
         logger?.debug('Final processed audio:', {
             outputSamples: channelData.length,
-            outputSampleRate: targetSampleRate,
+            outputSampleRate: effectiveTargetSampleRate,
             durationMs,
         })
 
@@ -184,7 +195,7 @@ export async function processAudioBuffer({
             channelData,
             samples: channelData.length,
             durationMs,
-            sampleRate: targetSampleRate,
+            sampleRate: effectiveTargetSampleRate,
             channels: processedBuffer.numberOfChannels,
         }
     } catch (error) {

package/android/src/androidTest/java/net/siteed/audiostudio/AudioFinalMetadataContractInstrumentedTest.kt

@@ -1,190 +0,0 @@
-package net.siteed.audiostudio
-
-import android.content.Context
-import android.net.Uri
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.After
-import org.junit.Assert.assertEquals
-import org.junit.Assert.assertTrue
-import org.junit.Before
-import org.junit.Test
-import org.junit.runner.RunWith
-import java.io.File
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-
-/**
- * Regression coverage for Android range processing where the final PCM bytes,
- * returned metadata, and WAV headers must all describe the post-conversion data.
- */
-@RunWith(AndroidJUnit4::class)
-class AudioFinalMetadataContractInstrumentedTest {
-    private lateinit var context: Context
-    private lateinit var filesDir: File
-    private lateinit var audioProcessor: AudioProcessor
-
-    @Before
-    fun setUp() {
-        context = InstrumentationRegistry.getInstrumentation().targetContext
-        filesDir = context.filesDir
-        audioProcessor = AudioProcessor(filesDir)
-        copyAssetToFilesDir("chorus.wav")
-    }
-
-    @After
-    fun tearDown() {
-        filesDir.listFiles()?.forEach { file ->
-            if (file.name.startsWith("final_metadata_contract_") || file.name == "chorus.wav") {
-                file.delete()
-            }
-        }
-    }
-
-    @Test
-    fun loadAudioRange_returnsMetadataFromFinalConvertedWavBytes() {
-        val audioData = audioProcessor.loadAudioRange(
-            fileUri = File(filesDir, "chorus.wav").absolutePath,
-            startTimeMs = 0,
-            endTimeMs = ONE_SECOND_MS,
-            config = DecodingConfig(
-                targetSampleRate = TARGET_SAMPLE_RATE,
-                targetChannels = TARGET_CHANNELS,
-                targetBitDepth = TARGET_BIT_DEPTH,
-                normalizeAudio = false
-            )
-        )
-
-        val converted = requireNotNull(audioData) { "Audio range should load" }
-        val bytesPerTargetFrame = TARGET_CHANNELS * BYTES_PER_TARGET_SAMPLE
-        val finalFrameCount = converted.data.size / bytesPerTargetFrame
-        val durationFromFinalBytes = finalFrameCount * 1_000L / TARGET_SAMPLE_RATE
-
-        assertEquals("sampleRate should describe final converted bytes", TARGET_SAMPLE_RATE, converted.sampleRate)
-        assertEquals("channels should describe final converted bytes", TARGET_CHANNELS, converted.channels)
-        assertEquals("bitDepth should describe final converted bytes", TARGET_BIT_DEPTH, converted.bitDepth)
-        assertEquals("final PCM data must end on a target frame boundary", 0, converted.data.size % bytesPerTargetFrame)
-        assertEquals(
-            "duration should be derived from actual final PCM bytes",
-            durationFromFinalBytes,
-            converted.durationMs
-        )
-        assertTrue(
-            "duration should remain close to requested range: ${converted.durationMs}ms",
-            kotlin.math.abs(converted.durationMs - ONE_SECOND_MS) <= 25
-        )
-    }
-
-    @Test
-    fun loadAudioRange_alignsConvertedWavBytesToTargetFrameSize() {
-        val audioData = audioProcessor.loadAudioRange(
-            fileUri = File(filesDir, "chorus.wav").absolutePath,
-            startTimeMs = 0,
-            endTimeMs = ONE_SECOND_MS,
-            config = DecodingConfig(
-                targetSampleRate = TARGET_SAMPLE_RATE,
-                targetChannels = TARGET_CHANNELS,
-                targetBitDepth = TARGET_BIT_DEPTH,
-                normalizeAudio = false
-            )
-        )
-
-        val converted = requireNotNull(audioData) { "Audio range should load" }
-        val bytesPerTargetFrame = TARGET_CHANNELS * BYTES_PER_TARGET_SAMPLE
-
-        assertEquals("final PCM data must end on a target frame boundary", 0, converted.data.size % bytesPerTargetFrame)
-    }
-
-    @Test
-    fun trimAudio_writesWavHeaderFromFinalConvertedBytes() {
-        val outputFileName = "final_metadata_contract_processor_trim.wav"
-        val trimmed = audioProcessor.trimAudio(
-            fileUri = File(filesDir, "chorus.wav").absolutePath,
-            startTimeMs = 0,
-            endTimeMs = ONE_SECOND_MS,
-            config = DecodingConfig(
-                targetSampleRate = TARGET_SAMPLE_RATE,
-                targetChannels = TARGET_CHANNELS,
-                targetBitDepth = TARGET_BIT_DEPTH,
-                normalizeAudio = false
-            ),
-            outputFileName = outputFileName
-        )
-
-        requireNotNull(trimmed) { "Trimmed audio should be returned" }
-        val header = readWavHeader(File(filesDir, outputFileName))
-
-        assertEquals("WAV header sample rate should be target sample rate", TARGET_SAMPLE_RATE, header.sampleRate)
-        assertEquals("WAV header channels should be target channels", TARGET_CHANNELS, header.channels)
-        assertEquals("WAV header bit depth should be target bit depth", TARGET_BIT_DEPTH, header.bitDepth)
-        assertEquals("WAV data chunk should match returned final PCM bytes", trimmed.data.size, header.dataSize)
-    }
-
-    @Test
-    fun audioTrimmer_honorsJsNumberOutputFormatWhenWritingWavHeader() {
-        val trimmer = AudioTrimmer(context, AudioFileHandler(filesDir))
-        val result = trimmer.trimAudio(
-            fileUri = Uri.fromFile(File(filesDir, "chorus.wav")).toString(),
-            startTimeMs = 0,
-            endTimeMs = ONE_SECOND_MS,
-            outputFileName = "final_metadata_contract_audio_trimmer",
-            outputFormat = mapOf(
-                "format" to "wav",
-                "sampleRate" to TARGET_SAMPLE_RATE.toDouble(),
-                "channels" to TARGET_CHANNELS.toDouble(),
-                "bitDepth" to TARGET_BIT_DEPTH.toDouble()
-            )
-        )
-
-        val outputPath = result["uri"] as String
-        val header = readWavHeader(File(outputPath))
-
-        assertEquals("Double sampleRate option should drive WAV header", TARGET_SAMPLE_RATE, header.sampleRate)
-        assertEquals("Double channels option should drive WAV header", TARGET_CHANNELS, header.channels)
-        assertEquals("Double bitDepth option should drive WAV header", TARGET_BIT_DEPTH, header.bitDepth)
-    }
-
-    private fun copyAssetToFilesDir(fileName: String) {
-        context.assets.open(fileName).use { input ->
-            File(filesDir, fileName).outputStream().use { output ->
-                input.copyTo(output)
-            }
-        }
-    }
-
-    private fun readWavHeader(file: File): WavHeader {
-        assertTrue("WAV file should exist: ${file.absolutePath}", file.exists())
-        val bytes = file.inputStream().use { it.readNBytes(44) }
-        assertEquals("RIFF", String(bytes.sliceArray(0..3)))
-        assertEquals("WAVE", String(bytes.sliceArray(8..11)))
-        assertEquals("data", String(bytes.sliceArray(36..39)))
-
-        return WavHeader(
-            channels = bytes.shortAt(22),
-            sampleRate = bytes.intAt(24),
-            bitDepth = bytes.shortAt(34),
-            dataSize = bytes.intAt(40)
-        )
-    }
-
-    private fun ByteArray.shortAt(offset: Int): Int =
-        ByteBuffer.wrap(this, offset, 2).order(ByteOrder.LITTLE_ENDIAN).short.toInt()
-
-    private fun ByteArray.intAt(offset: Int): Int =
-        ByteBuffer.wrap(this, offset, 4).order(ByteOrder.LITTLE_ENDIAN).int
-
-    private data class WavHeader(
-        val channels: Int,
-        val sampleRate: Int,
-        val bitDepth: Int,
-        val dataSize: Int
-    )
-
-    companion object {
-        private const val ONE_SECOND_MS = 1_000L
-        private const val TARGET_SAMPLE_RATE = 16_000
-        private const val TARGET_CHANNELS = 2
-        private const val TARGET_BIT_DEPTH = 16
-        private const val BYTES_PER_TARGET_SAMPLE = TARGET_BIT_DEPTH / 8
-    }
-}

package/android/src/androidTest/java/net/siteed/audiostudio/AudioProcessorInstrumentedTest.kt

@@ -1,197 +0,0 @@
-package net.siteed.audiostudio
-
-import androidx.test.ext.junit.runners.AndroidJUnit4
-import androidx.test.platform.app.InstrumentationRegistry
-import org.junit.Test
-import org.junit.Assert.*
-import org.junit.Before
-import org.junit.After
-import org.junit.runner.RunWith
-import java.io.File
-import kotlin.math.abs
-
-/**
- * Instrumented tests for AudioProcessor that require Android framework components.
- * These tests run on an Android device/emulator and have access to MediaExtractor/MediaCodec.
- */
-@RunWith(AndroidJUnit4::class)
-class AudioProcessorInstrumentedTest {
-    private lateinit var context: android.content.Context
-    private lateinit var audioProcessor: AudioProcessor
-    private lateinit var testFilesDir: File
-
-    @Before
-    fun setUp() {
-        context = InstrumentationRegistry.getInstrumentation().targetContext
-        testFilesDir = context.filesDir
-        audioProcessor = AudioProcessor(testFilesDir)
-        
-        // Copy test assets to files directory
-        copyTestAssets()
-    }
-
-    @After
-    fun tearDown() {
-        // Clean up test files
-        testFilesDir.listFiles()?.forEach { file ->
-            if (file.name.endsWith(".wav")) {
-                file.delete()
-            }
-        }
-    }
-
-    private fun copyTestAssets() {
-        val assetManager = context.assets
-        val testFiles = listOf("jfk.wav", "chorus.wav", "recorder_hello_world.wav")
-        
-        testFiles.forEach { fileName ->
-            try {
-                assetManager.open(fileName).use { input ->
-                    File(testFilesDir, fileName).outputStream().use { output ->
-                        input.copyTo(output)
-                    }
-                }
-            } catch (e: Exception) {
-                // If asset doesn't exist, skip it
-                println("Warning: Test asset $fileName not found")
-            }
-        }
-    }
-
-    // ========== Audio Loading Tests ==========
-
-    @Test
-    fun testLoadAudioFromAnyFormat_loadsWavFile() {
-        // Given
-        val wavFile = File(testFilesDir, "jfk.wav")
-        assertTrue("Test file should exist", wavFile.exists())
-
-        // When
-        val audioData = audioProcessor.loadAudioFromAnyFormat(wavFile.absolutePath, null)
-
-        // Then
-        assertNotNull("Audio data should not be null", audioData)
-        assertEquals("Sample rate should be 16000", 16000, audioData!!.sampleRate)
-        assertEquals("Should be mono", 1, audioData.channels)
-        assertEquals("Should be 16-bit", 16, audioData.bitDepth)
-        assertTrue("Should have audio data", audioData.data.isNotEmpty())
-        assertTrue("Duration should be positive", audioData.durationMs > 0)
-    }
-
-    @Test
-    fun testLoadAudioFromAnyFormat_withDecodingConfig() {
-        // Given
-        val wavFile = File(testFilesDir, "jfk.wav")
-        val config = DecodingConfig(
-            targetSampleRate = 44100,
-            targetChannels = 2,  // Test channel conversion - bug fixed
-            targetBitDepth = 16,
-            normalizeAudio = false
-        )
-
-        // When
-        val audioData = audioProcessor.loadAudioFromAnyFormat(wavFile.absolutePath, config)
-
-        // Then
-        assertNotNull("Audio data should not be null", audioData)
-        assertEquals("Sample rate should be converted to 44100", 44100, audioData!!.sampleRate)
-        assertEquals("Should be converted to stereo", 2, audioData.channels)
-    }
-
-    // ========== Audio Trimming Tests ==========
-
-    @Test
-    fun testTrimAudio_basicTrimming() {
-        // Given
-        val wavFile = File(testFilesDir, "jfk.wav")
-        val startTimeMs = 1000L
-        val endTimeMs = 3000L
-
-        // When
-        val trimmedAudio = audioProcessor.trimAudio(
-            fileUri = wavFile.absolutePath,
-            startTimeMs = startTimeMs,
-            endTimeMs = endTimeMs,
-            config = null,
-            outputFileName = "trimmed_jfk.wav"
-        )
-
-        // Then
-        assertNotNull("Trimmed audio should not be null", trimmedAudio)
-        
-        // Verify the trimmed file was created
-        val trimmedFile = File(testFilesDir, "trimmed_jfk.wav")
-        assertTrue("Trimmed file should exist", trimmedFile.exists())
-    }
-
-    // ========== Mel Spectrogram Tests ==========
-
-    @Test
-    fun testExtractMelSpectrogram_basicGeneration() {
-        // Given
-        val wavFile = File(testFilesDir, "jfk.wav")
-        val audioData = audioProcessor.loadAudioFromAnyFormat(wavFile.absolutePath, null)
-        assertNotNull("Audio data should load", audioData)
-
-        // When
-        val melSpectrogram = audioProcessor.extractMelSpectrogram(
-            audioData = audioData!!,
-            windowSizeMs = 25f,
-            hopLengthMs = 10f,
-            nMels = 40,
-            fftLength = 512
-        )
-
-        // Then
-        assertNotNull("Mel spectrogram should not be null", melSpectrogram)
-        assertTrue("Should have time frames", melSpectrogram.spectrogram.isNotEmpty())
-        assertEquals("Should have 40 mel bins", 40, melSpectrogram.spectrogram[0].size)
-        
-        // Verify timestamps
-        assertTrue("Should have timestamps", melSpectrogram.timeStamps.isNotEmpty())
-        assertEquals("Timestamps should match frames", 
-            melSpectrogram.spectrogram.size, melSpectrogram.timeStamps.size)
-        
-        // Verify frequencies
-        assertEquals("Should have 40 frequency bins", 40, melSpectrogram.frequencies.size)
-        assertTrue("Frequencies should be ascending", 
-            melSpectrogram.frequencies.zip(melSpectrogram.frequencies.drop(1))
-                .all { (a, b) -> a < b })
-    }
-
-    // ========== Preview Generation Tests ==========
-
-    @Test
-    fun testGeneratePreview_basicPreview() {
-        // Given
-        val wavFile = File(testFilesDir, "chorus.wav")
-        val audioData = audioProcessor.loadAudioFromAnyFormat(wavFile.absolutePath, null)
-        assertNotNull("Audio data should load", audioData)
-        
-        val config = RecordingConfig(
-            sampleRate = audioData!!.sampleRate,
-            channels = audioData.channels,
-            encoding = "pcm_16bit",
-            segmentDurationMs = 20 // 50 points per second
-        )
-
-        // When
-        val preview = audioProcessor.generatePreview(
-            audioData = audioData,
-            numberOfPoints = 100,
-            startTimeMs = null,
-            endTimeMs = null,
-            config = config
-        )
-
-        // Then
-        assertNotNull("Preview should not be null", preview)
-        assertEquals("Should have 100 data points", 100, preview.dataPoints.size)
-        
-        // Verify amplitude range
-        assertTrue("Min amplitude should be reasonable", preview.amplitudeRange.min >= 0)
-        assertTrue("Max amplitude should be reasonable", preview.amplitudeRange.max <= 1)
-        assertTrue("Max should be greater than min", 
-            preview.amplitudeRange.max > preview.amplitudeRange.min)
-    }
-}