@siteed/expo-audio-studio 2.18.5 → 3.0.0

package/android/src/test/java/net/siteed/audiostream/AudioFormatUtilsTest.kt

@@ -1,273 +0,0 @@
-package net.siteed.audiostream
-
-import org.junit.Test
-import org.junit.Assert.*
-import java.nio.ByteBuffer
-import java.nio.ByteOrder
-import kotlin.math.abs
-
-class AudioFormatUtilsTest {
-
-    @Test
-    fun testConvertBitDepth_8to16() {
-        // Given - 8-bit PCM data (unsigned, centered at 128)
-        val input8bit = byteArrayOf(0, 64, 128.toByte(), 192.toByte(), 255.toByte())
-        
-        // When
-        val output16bit = AudioFormatUtils.convertBitDepth(input8bit, 8, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(output16bit).order(ByteOrder.LITTLE_ENDIAN)
-        val samples = ShortArray(output16bit.size / 2)
-        buffer.asShortBuffer().get(samples)
-        
-        // Verify conversion (8-bit 128 = silence = 16-bit 0)
-        assertEquals("First sample should be -32768", -32768, samples[0].toInt())
-        assertEquals("Middle sample (128) should be 0", 0, samples[2].toInt())
-        assertEquals("Last sample should be 32767", 32767, samples[4].toInt())
-    }
-
-    @Test
-    fun testConvertBitDepth_16to8() {
-        // Given - 16-bit PCM data
-        val buffer16 = ByteBuffer.allocate(10).order(ByteOrder.LITTLE_ENDIAN)
-        buffer16.putShort(-32768) // Min value
-        buffer16.putShort(-16384) // -0.5
-        buffer16.putShort(0)      // Silence
-        buffer16.putShort(16384)  // 0.5
-        buffer16.putShort(32767)  // Max value
-        
-        // When
-        val output8bit = AudioFormatUtils.convertBitDepth(buffer16.array(), 16, 8)
-        
-        // Then
-        assertEquals("Should have 5 samples", 5, output8bit.size)
-        assertEquals("Min should convert to 0", 0, output8bit[0].toInt() and 0xFF)
-        assertEquals("Silence should convert to 128", 128, output8bit[2].toInt() and 0xFF)
-        assertEquals("Max should convert to 255", 255, output8bit[4].toInt() and 0xFF)
-    }
-
-    @Test
-    fun testConvertBitDepth_16to32() {
-        // Given - 16-bit PCM data
-        val buffer16 = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN)
-        buffer16.putShort(-32768) // Min
-        buffer16.putShort(0)      // Silence
-        buffer16.putShort(32767)  // Max
-        
-        // When
-        val output32bit = AudioFormatUtils.convertBitDepth(buffer16.array(), 16, 32)
-        
-        // Then
-        val buffer32 = ByteBuffer.wrap(output32bit).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 3 32-bit samples", 12, output32bit.size)
-        
-        // Check values (scaled appropriately)
-        val sample1 = buffer32.getInt()
-        val sample2 = buffer32.getInt()
-        val sample3 = buffer32.getInt()
-        
-        assertTrue("Min value should be negative", sample1 < 0)
-        assertEquals("Silence should be 0", 0, sample2)
-        assertTrue("Max value should be positive", sample3 > 0)
-    }
-
-    @Test
-    fun testConvertBitDepth_32to16() {
-        // Given - 32-bit PCM data
-        val buffer32 = ByteBuffer.allocate(12).order(ByteOrder.LITTLE_ENDIAN)
-        buffer32.putInt(Int.MIN_VALUE)  // Min
-        buffer32.putInt(0)              // Silence
-        buffer32.putInt(Int.MAX_VALUE)  // Max
-        
-        // When
-        val output16bit = AudioFormatUtils.convertBitDepth(buffer32.array(), 32, 16)
-        
-        // Then
-        val buffer16 = ByteBuffer.wrap(output16bit).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 3 16-bit samples", 6, output16bit.size)
-        
-        assertEquals("Min should convert to -32768", -32768, buffer16.getShort().toInt())
-        assertEquals("Silence should be 0", 0, buffer16.getShort().toInt())
-        assertEquals("Max should convert to 32767", 32767, buffer16.getShort().toInt())
-    }
-
-    @Test
-    fun testConvertBitDepth_sameDepth() {
-        // Given
-        val input = byteArrayOf(1, 2, 3, 4, 5, 6)
-        
-        // When - Convert 16 to 16 (no-op)
-        val output = AudioFormatUtils.convertBitDepth(input, 16, 16)
-        
-        // Then
-        assertArrayEquals("Should return same data", input, output)
-    }
-
-    @Test
-    fun testConvertBitDepth_emptyData() {
-        // Given
-        val emptyData = byteArrayOf()
-        
-        // When
-        val output = AudioFormatUtils.convertBitDepth(emptyData, 16, 32)
-        
-        // Then
-        assertEquals("Should return empty array", 0, output.size)
-    }
-
-    @Test
-    fun testConvertChannels_monoToStereo() {
-        // Given - Mono 16-bit data
-        val monoData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(1000)
-            putShort(2000)
-            putShort(3000)
-        }.array()
-        
-        // When
-        val stereoData = AudioFormatUtils.convertChannels(monoData, 1, 2, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(stereoData).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 6 samples (3 stereo pairs)", 12, stereoData.size)
-        
-        // Each mono sample should be duplicated to both channels
-        assertEquals("L1", 1000, buffer.getShort().toInt())
-        assertEquals("R1", 1000, buffer.getShort().toInt())
-        assertEquals("L2", 2000, buffer.getShort().toInt())
-        assertEquals("R2", 2000, buffer.getShort().toInt())
-        assertEquals("L3", 3000, buffer.getShort().toInt())
-        assertEquals("R3", 3000, buffer.getShort().toInt())
-    }
-
-    @Test
-    fun testConvertChannels_stereoToMono() {
-        // Given - Stereo 16-bit data
-        val stereoData = ByteBuffer.allocate(8).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(1000)  // L1
-            putShort(2000)  // R1
-            putShort(3000)  // L2
-            putShort(4000)  // R2
-        }.array()
-        
-        // When
-        val monoData = AudioFormatUtils.convertChannels(stereoData, 2, 1, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(monoData).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Should have 2 mono samples", 4, monoData.size)
-        
-        // Each mono sample should be average of L+R
-        assertEquals("Sample 1", 1500, buffer.getShort().toInt()) // (1000+2000)/2
-        assertEquals("Sample 2", 3500, buffer.getShort().toInt()) // (3000+4000)/2
-    }
-
-    @Test
-    fun testNormalizeAudio_quietSignal() {
-        // Given - Quiet 16-bit signal
-        val quietData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(100)
-            putShort(-100)
-            putShort(50)
-        }.array()
-        
-        // When
-        val normalized = AudioFormatUtils.normalizeAudio(quietData, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
-        val maxSample = abs(buffer.getShort().toInt())
-        buffer.rewind()
-        
-        // The loudest sample should be close to max value
-        assertTrue("Should be normalized to near max", maxSample > 30000)
-    }
-
-    @Test
-    fun testNormalizeAudio_alreadyLoud() {
-        // Given - Already loud signal
-        val loudData = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(32000)
-            putShort(-32000)
-        }.array()
-        
-        // When
-        val normalized = AudioFormatUtils.normalizeAudio(loudData, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
-        val sample1 = abs(buffer.getShort().toInt())
-        val sample2 = abs(buffer.getShort().toInt())
-        
-        // Should be normalized but not clipped
-        assertTrue("Samples should be near max", sample1 > 32000 && sample2 > 32000)
-        assertTrue("Samples should not exceed max", sample1 <= 32767 && sample2 <= 32767)
-    }
-
-    @Test
-    fun testNormalizeAudio_silentSignal() {
-        // Given - Silent signal
-        val silentData = ByteBuffer.allocate(6).order(ByteOrder.LITTLE_ENDIAN).apply {
-            putShort(0)
-            putShort(0)
-            putShort(0)
-        }.array()
-        
-        // When
-        val normalized = AudioFormatUtils.normalizeAudio(silentData, 16)
-        
-        // Then
-        val buffer = ByteBuffer.wrap(normalized).order(ByteOrder.LITTLE_ENDIAN)
-        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
-        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
-        assertEquals("Silent should remain silent", 0, buffer.getShort().toInt())
-    }
-
-    @Test
-    fun testResampleAudio_upsample() {
-        // Given - 8kHz mono audio
-        val samples8k = floatArrayOf(0.0f, 0.5f, 1.0f, 0.5f, 0.0f, -0.5f, -1.0f, -0.5f)
-        
-        // When - Upsample to 16kHz
-        val samples16k = AudioFormatUtils.resampleAudio(samples8k, 8000, 16000)
-        
-        // Then
-        assertEquals("Should have approximately double samples", 16, samples16k.size)
-        // First and last samples should match
-        assertEquals("First sample", samples8k[0], samples16k[0], 0.01f)
-        assertEquals("Last sample", samples8k.last(), samples16k.last(), 0.01f)
-    }
-
-    @Test
-    fun testResampleAudio_downsample() {
-        // Given - 16kHz mono audio
-        val samples16k = floatArrayOf(
-            0.0f, 0.25f, 0.5f, 0.75f, 1.0f, 0.75f, 0.5f, 0.25f,
-            0.0f, -0.25f, -0.5f, -0.75f, -1.0f, -0.75f, -0.5f, -0.25f
-        )
-        
-        // When - Downsample to 8kHz
-        val samples8k = AudioFormatUtils.resampleAudio(samples16k, 16000, 8000)
-        
-        // Then
-        assertEquals("Should have approximately half samples", 8, samples8k.size)
-        // Check general shape is preserved
-        val maxValue = samples8k.maxOrNull() ?: 0f
-        val minValue = samples8k.minOrNull() ?: 0f
-        assertTrue("Peak should be preserved", maxValue > 0.9f)
-        assertTrue("Trough should be preserved", minValue < -0.9f)
-    }
-
-    @Test
-    fun testResampleAudio_sameRate() {
-        // Given
-        val samples = floatArrayOf(0.1f, 0.2f, 0.3f, 0.4f, 0.5f)
-        
-        // When - Same sample rate
-        val resampled = AudioFormatUtils.resampleAudio(samples, 44100, 44100)
-        
-        // Then
-        assertArrayEquals("Should return same samples", samples, resampled, 0.001f)
-    }
-} 

package/android/src/test/java/net/siteed/audiostream/DeviceDisconnectionFallbackUnitTest.kt

@@ -1,140 +0,0 @@
-package net.siteed.audiostream
-
-import org.junit.Assert.*
-import org.junit.Test
-
-/**
- * Unit test for Device Disconnection Fallback Behavior
- * 
- * Tests the configuration and expected behavior for device disconnection scenarios.
- */
-class DeviceDisconnectionFallbackUnitTest {
-
-    @Test
-    fun `test RecordingConfig stores deviceDisconnectionBehavior correctly`() {
-        // Test fallback behavior
-        val fallbackConfig = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit",
-            deviceDisconnectionBehavior = "fallback"
-        )
-        
-        assertEquals("Should store fallback behavior", "fallback", fallbackConfig.deviceDisconnectionBehavior)
-        
-        // Test pause behavior
-        val pauseConfig = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit",
-            deviceDisconnectionBehavior = "pause"
-        )
-        
-        assertEquals("Should store pause behavior", "pause", pauseConfig.deviceDisconnectionBehavior)
-        
-        // Test default behavior (should be null)
-        val defaultConfig = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit"
-        )
-        
-        assertNull("Default behavior should be null", defaultConfig.deviceDisconnectionBehavior)
-    }
-
-    @Test
-    fun `test AudioRecorderManager stores deviceDisconnectionBehavior`() {
-        val config = RecordingConfig(
-            sampleRate = 44100,
-            channels = 1,
-            encoding = "pcm_16bit",
-            deviceDisconnectionBehavior = "fallback"
-        )
-        
-        // Verify the config has the correct behavior
-        assertEquals("fallback", config.deviceDisconnectionBehavior)
-        
-        // AudioRecorderManager should use this configuration
-        // The actual AudioRecorderManager.getDeviceDisconnectionBehavior() 
-        // will return this value when recording is started with this config
-    }
-
-    @Test
-    fun `test device disconnection behavior values`() {
-        val validBehaviors = listOf("fallback", "pause")
-        
-        for (behavior in validBehaviors) {
-            val config = RecordingConfig(
-                sampleRate = 44100,
-                channels = 1,
-                encoding = "pcm_16bit",
-                deviceDisconnectionBehavior = behavior
-            )
-            
-            assertEquals("Should accept $behavior behavior", behavior, config.deviceDisconnectionBehavior)
-        }
-    }
-
-    @Test
-    fun `test interruption event reasons`() {
-        // Test expected event reasons for device disconnection scenarios
-        val expectedReasons = mapOf(
-            "fallback" to listOf("deviceFallback", "deviceSwitchFailed"),
-            "pause" to listOf("deviceDisconnected")
-        )
-        
-        // Verify the expected reasons are valid strings
-        expectedReasons.forEach { (behavior, reasons) ->
-            assertNotNull("Behavior $behavior should have reasons", reasons)
-            assertTrue("Behavior $behavior should have at least one reason", reasons.isNotEmpty())
-            
-            reasons.forEach { reason ->
-                assertNotNull("Reason should not be null", reason)
-                assertTrue("Reason should not be empty", reason.isNotEmpty())
-            }
-        }
-    }
-
-    @Test
-    fun `test fallback behavior logic`() {
-        // Test the logic for fallback behavior
-        val behavior = "fallback"
-        
-        // When behavior is fallback:
-        // 1. Should attempt to get default device
-        // 2. If default device exists, should select it
-        // 3. If selection succeeds, should send "deviceFallback" event
-        // 4. If selection fails, should pause and send "deviceSwitchFailed" event
-        // 5. If no default device, should pause and send "deviceDisconnected" event
-        
-        when (behavior) {
-            "fallback" -> {
-                // This branch should be taken
-                assertTrue("Should handle fallback behavior", true)
-            }
-            else -> {
-                fail("Should not reach default case for fallback behavior")
-            }
-        }
-    }
-
-    @Test
-    fun `test pause behavior logic`() {
-        // Test the logic for pause behavior
-        val behavior = "pause"
-        
-        // When behavior is pause:
-        // 1. Should pause recording immediately
-        // 2. Should send "deviceDisconnected" event
-        
-        when (behavior) {
-            "fallback" -> {
-                fail("Should not handle as fallback")
-            }
-            else -> {
-                // This branch should be taken for pause
-                assertTrue("Should handle pause behavior", true)
-            }
-        }
-    }
-}

package/android/src/test/resources/generate_test_audio.py

@@ -1,94 +0,0 @@
-#!/usr/bin/env python3
-"""
-Generate test WAV files for Android unit tests
-"""
-
-import wave
-import struct
-import math
-import array
-
-def generate_sine_wave(frequency, duration, sample_rate, amplitude=0.5):
-    """Generate sine wave samples"""
-    num_samples = int(duration * sample_rate)
-    samples = []
-    for i in range(num_samples):
-        t = i / sample_rate
-        value = amplitude * math.sin(2 * math.pi * frequency * t)
-        # Convert to 16-bit PCM
-        pcm_value = int(value * 32767)
-        samples.append(pcm_value)
-    return samples
-
-def create_wav_file(filename, channels, sample_rate, bit_depth, duration, frequency=440):
-    """Create a WAV file with specified parameters"""
-    print(f"Creating {filename}...")
-    
-    # Generate samples for left channel (or mono)
-    samples = generate_sine_wave(frequency, duration, sample_rate)
-    
-    # For stereo, generate right channel with different frequency
-    if channels == 2:
-        right_samples = generate_sine_wave(frequency * 1.5, duration, sample_rate)
-    
-    # Prepare the data
-    if bit_depth == 16:
-        # Create array of signed shorts
-        audio_data = array.array('h')  # signed short
-        
-        for i in range(len(samples)):
-            if channels == 1:
-                audio_data.append(samples[i])
-            else:
-                # Interleave stereo samples
-                audio_data.append(samples[i])
-                audio_data.append(right_samples[i])
-    elif bit_depth == 8:
-        # Create array of unsigned bytes
-        audio_data = array.array('B')  # unsigned char
-        
-        for i in range(len(samples)):
-            # Convert to 8-bit unsigned
-            sample_8bit = ((samples[i] + 32768) >> 8) & 0xFF
-            if channels == 1:
-                audio_data.append(sample_8bit)
-            else:
-                right_8bit = ((right_samples[i] + 32768) >> 8) & 0xFF
-                audio_data.append(sample_8bit)
-                audio_data.append(right_8bit)
-    else:
-        raise ValueError(f"Unsupported bit depth: {bit_depth}")
-    
-    # Write WAV file
-    with wave.open(filename, 'wb') as wav_file:
-        wav_file.setnchannels(channels)
-        wav_file.setsampwidth(bit_depth // 8)
-        wav_file.setframerate(sample_rate)
-        wav_file.writeframes(audio_data.tobytes())
-    
-    print(f"  Created: {filename} ({duration}s, {sample_rate}Hz, {channels}ch, {bit_depth}bit)")
-
-# Generate test files
-if __name__ == "__main__":
-    try:
-        # Basic mono file
-        create_wav_file("test_mono_16bit_44100.wav", 
-                       channels=1, sample_rate=44100, bit_depth=16, duration=1.0)
-        
-        # Stereo file
-        create_wav_file("test_stereo_16bit_48000.wav", 
-                       channels=2, sample_rate=48000, bit_depth=16, duration=1.0)
-        
-        # Short duration file
-        create_wav_file("test_short_100ms.wav", 
-                       channels=1, sample_rate=44100, bit_depth=16, duration=0.1)
-        
-        # Silent file (0 Hz frequency)
-        create_wav_file("test_silence.wav", 
-                       channels=1, sample_rate=44100, bit_depth=16, duration=0.5, frequency=0)
-        
-        print("\nAll test WAV files generated successfully!")
-    except Exception as e:
-        print(f"Error: {e}")
-        import traceback
-        traceback.print_exc() 

package/app.plugin.js

@@ -1,3 +0,0 @@
-// Plugin for app.json usage (regular Node.js context)
-const plugin = require('./plugin/build/index.js')
-module.exports = plugin.default || plugin

package/build/cjs/AudioAnalysis/AudioAnalysis.types.js

@@ -1,4 +0,0 @@
-"use strict";
-// packages/expo-audio-stream/src/AudioAnalysis/AudioAnalysis.types.ts
-Object.defineProperty(exports, "__esModule", { value: true });
-//# sourceMappingURL=AudioAnalysis.types.js.map

package/build/cjs/AudioAnalysis/AudioAnalysis.types.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"AudioAnalysis.types.js","sourceRoot":"","sources":["../../../src/AudioAnalysis/AudioAnalysis.types.ts"],"names":[],"mappings":";AAAA,sEAAsE","sourcesContent":["// packages/expo-audio-stream/src/AudioAnalysis/AudioAnalysis.types.ts\n\nimport { BitDepth, ConsoleLike } from '../ExpoAudioStream.types'\n\n/**\n * Represents the configuration for decoding audio data.\n */\nexport interface DecodingConfig {\n    /** Target sample rate for decoded audio (Android and Web) */\n    targetSampleRate?: number\n    /** Target number of channels (Android and Web) */\n    targetChannels?: number\n    /** Target bit depth (Android and Web) */\n    targetBitDepth?: BitDepth\n    /** Whether to normalize audio levels (Android and Web) */\n    normalizeAudio?: boolean\n}\n\n/**\n * Represents speech-related features extracted from audio.\n */\nexport interface SpeechFeatures {\n    isActive: boolean // Whether speech is detected in this segment\n    speakerId?: number // Optional speaker identification\n    // Could add more speech-related features here like:\n    // confidence: number\n    // language?: string\n    // sentiment?: number\n    // etc.\n}\n\n/**\n * Represents various audio features extracted from an audio signal.\n */\nexport interface AudioFeatures {\n    energy?: number // The infinite integral of the squared signal, representing the overall energy of the audio.\n    mfcc?: number[] // Mel-frequency cepstral coefficients, describing the short-term power spectrum of a sound.\n    rms?: number // Root mean square value, indicating the amplitude of the audio signal.\n    minAmplitude?: number // Minimum amplitude value in the audio signal.\n    maxAmplitude?: number // Maximum amplitude value in the audio signal.\n    zcr?: number // Zero-crossing rate, indicating the rate at which the signal changes sign.\n    spectralCentroid?: number // The center of mass of the spectrum, indicating the brightness of the sound.\n    spectralFlatness?: number // Measure of the flatness of the spectrum, indicating how noise-like the signal is.\n    spectralRolloff?: number // The frequency below which a specified percentage (usually 85%) of the total spectral energy lies.\n    spectralBandwidth?: number // The width of the spectrum, indicating the range of frequencies present.\n    chromagram?: number[] // Chromagram, representing the 12 different pitch classes of the audio.\n    tempo?: number // Estimated tempo of the audio signal, measured in beats per minute (BPM).\n    hnr?: number // Harmonics-to-noise ratio, indicating the proportion of harmonics to noise in the audio signal.\n    melSpectrogram?: number[] // Mel-scaled spectrogram representation of the audio.\n    spectralContrast?: number[] // Spectral contrast features representing the difference between peaks and valleys.\n    tonnetz?: number[] // Tonal network features representing harmonic relationships.\n    pitch?: number // Pitch of the audio signal, measured in Hertz (Hz).\n    crc32?: number // crc32 checksum of the audio signal, used to verify the integrity of the audio.\n}\n\n/**\n * Options to specify which audio features to extract.\n * Note: Advanced features (spectral features, chromagram, pitch, etc.) are experimental,\n * especially during live recording, due to high processing requirements.\n */\nexport interface AudioFeaturesOptions {\n    // Basic features - well optimized\n    energy?: boolean\n    rms?: boolean\n    zcr?: boolean\n\n    // Advanced features - experimental, may impact performance in live recording\n    mfcc?: boolean\n    spectralCentroid?: boolean\n    spectralFlatness?: boolean\n    spectralRolloff?: boolean\n    spectralBandwidth?: boolean\n    chromagram?: boolean\n    tempo?: boolean\n    hnr?: boolean\n    melSpectrogram?: boolean\n    spectralContrast?: boolean\n    tonnetz?: boolean\n    pitch?: boolean\n\n    // Utility\n    crc32?: boolean\n}\n\n/**\n * Represents a single data point in the audio analysis.\n */\nexport interface DataPoint {\n    id: number\n    amplitude: number // Peak amplitude for the segment\n    rms: number // Root mean square value\n    dB: number // dBFS (decibels relative to full scale) computed from RMS value\n    silent: boolean // Always computed\n    features?: AudioFeatures\n    speech?: SpeechFeatures\n    startTime?: number\n    endTime?: number\n    // start / end position in bytes\n    startPosition?: number\n    endPosition?: number\n    // number of audio samples for this point (samples size depends on bit depth)\n    samples?: number\n}\n\n/**\n * Represents the complete data from the audio analysis.\n */\nexport interface AudioAnalysis {\n    segmentDurationMs: number // Duration of each segment in milliseconds\n    durationMs: number // Duration of the audio in milliseconds\n    /**\n     * Bit depth used for audio analysis processing.\n     *\n     * **Important**: This represents the internal processing bit depth, which may differ\n     * from the recording bit depth. Audio is typically converted to 32-bit float for\n     * analysis to ensure precision in calculations, regardless of the original recording format.\n     *\n     * Platform behavior:\n     * - iOS: Always 32 (float processing)\n     * - Android: Always 32 (float processing)\n     * - Web: Always 32 (Web Audio API standard)\n     *\n     * The actual recorded file will maintain the requested bit depth (8, 16, or 32).\n     */\n    bitDepth: number\n    samples: number // Size of the audio in bytes\n    numberOfChannels: number // Number of audio channels\n    sampleRate: number // Sample rate of the audio\n    dataPoints: DataPoint[] // Array of data points from the analysis.\n    amplitudeRange: {\n        min: number\n        max: number\n    }\n    rmsRange: {\n        min: number\n        max: number\n    }\n    extractionTimeMs: number // Time taken to extract/process the analysis in milliseconds\n    // TODO: speaker changes into a broader speech analysis section\n    speechAnalysis?: {\n        speakerChanges: {\n            timestamp: number\n            speakerId: number\n        }[]\n        // Could add more speech analysis data here like:\n        // dominantSpeaker?: number\n        // totalSpeechDuration?: number\n        // speakerStats?: { [speakerId: number]: { duration: number, segments: number } }\n    }\n}\n\n/**\n * Options for specifying a time range within an audio file.\n */\nexport interface AudioRangeOptions {\n    /** Start time in milliseconds */\n    startTimeMs?: number\n    /** End time in milliseconds */\n    endTimeMs?: number\n}\n\n/**\n * Options for generating a quick preview of audio waveform.\n * This is optimized for UI rendering with a specified number of points.\n */\nexport interface PreviewOptions extends AudioRangeOptions {\n    /** URI of the audio file to analyze */\n    fileUri: string\n    /**\n     * Total number of points to generate for the preview.\n     * @default 100\n     */\n    numberOfPoints?: number\n    /**\n     * Optional logger for debugging.\n     */\n    logger?: ConsoleLike\n    /**\n     * Optional configuration for decoding the audio file.\n     * Defaults to:\n     * - targetSampleRate: undefined (keep original)\n     * - targetChannels: undefined (keep original)\n     * - targetBitDepth: 16\n     * - normalizeAudio: false\n     */\n    decodingOptions?: DecodingConfig\n}\n\n/**\n * Options for mel-spectrogram extraction\n *\n * @experimental This feature is experimental and currently only available on Android.\n * The API may change in future versions.\n */\nexport interface ExtractMelSpectrogramOptions {\n    fileUri?: string // Path to audio file\n    arrayBuffer?: ArrayBuffer // Raw audio buffer\n    windowSizeMs: number // Window size in ms (e.g., 25)\n    hopLengthMs: number // Hop length in ms (e.g., 10)\n    nMels: number // Number of mel filters (e.g., 60)\n    fMin?: number // Min frequency (default: 0)\n    fMax?: number // Max frequency (default: sampleRate / 2)\n    windowType?: 'hann' | 'hamming' // Window function (default: 'hann')\n    normalize?: boolean // Mean normalization (default: false)\n    logScale?: boolean // Log scaling of mel energies (default: true)\n    decodingOptions?: DecodingConfig // Audio decoding settings\n    startTimeMs?: number // Optional start time\n    endTimeMs?: number // Optional end time\n    logger?: ConsoleLike\n}\n\n/**\n * Return type for mel spectrogram extraction\n *\n * @experimental This feature is experimental and currently only available on Android.\n * The API may change in future versions.\n */\nexport interface MelSpectrogram {\n    spectrogram: number[][] // 2D array [time][mel]\n    sampleRate: number // Audio sample rate\n    nMels: number // Number of mel filters\n    timeSteps: number // Number of time frames\n    durationMs: number // Audio duration in ms\n}\n"]}