@siteed/expo-audio-stream 2.0.0 → 2.1.0

package/CHANGELOG.md

@@ -8,6 +8,20 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 ## [Unreleased]
 
 
+## [2.1.0] - 2025-03-04
+### Changed
+- feat(docs): enhance audio processing documentation and examples (#158) ([26afd49](https://github.com/deeeed/expo-audio-stream/commit/26afd4938e1c626294f40b50a84fe15f5c2bb6a1))
+- feat: Add Mel Spectrogram Extraction and Language Detection to Audio Processing (#157) ([4129dee](https://github.com/deeeed/expo-audio-stream/commit/4129dee87c27dd5a9911c85e3dbf045507876cc1))
+- feat: enhance audio import functionality and decibel visualization (#156) ([2dbecc7](https://github.com/deeeed/expo-audio-stream/commit/2dbecc7bd0ea46edd80c2b0e28dd2a0525953362))
+- feat(trim): Implement iOS trim support with custom filename and format improvements (#152) ([dd49be4](https://github.com/deeeed/expo-audio-stream/commit/dd49be42bccbf3ae6cced8c3662237e1668ec2de))
+- feat: Add Sample Rate Control and Web Trimming Support to Expo Audio Stream (#151) ([9158eec](https://github.com/deeeed/expo-audio-stream/commit/9158eeccc10e25ac77ba3a99185b4dbc5abfb353))
+- feat: Enhance audio trimming with optimized processing and detailed feedback (#150) ([41a6945](https://github.com/deeeed/expo-audio-stream/commit/41a694528d1e803dc0012948eec4edfdc336b4fc))
+- feat(trim): add audio trimming functionality with visualization and preview (Android only) (#149) ([cba03dc](https://github.com/deeeed/expo-audio-stream/commit/cba03dc920eb8a1f111b45e8404a42e48076b7cd))
+- chore(expo-audio-stream): release @siteed/expo-audio-stream@2.0.1 ([c77cfc8](https://github.com/deeeed/expo-audio-stream/commit/c77cfc8b70f87a12bb19fa03b245cda7ed2496e1))
+## [2.0.1] - 2025-02-27
+### Changed
+- refactor: update background mode handling for audio stream plugin ([e7e98cc](https://github.com/deeeed/expo-audio-stream/commit/e7e98cc60b7965770dcf25e9ae74cb356e1e7097))
+- chore(expo-audio-stream): release @siteed/expo-audio-stream@2.0.0 ([356d3f4](https://github.com/deeeed/expo-audio-stream/commit/356d3f40ffb66806eeecb86d12bcbe5d60b7eea6))
 ## [2.0.0] - 2025-02-27
 ### Changed
 - feat(playground): Enhance Audio Playground with Improved UX and Sample Audio Loading (#148) ([09d2794](https://github.com/deeeed/expo-audio-stream/commit/09d27940dcffa60e662c828742f4577bca5327f9))
@@ -154,7 +168,9 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Feature: Audio features extraction during recording.
 - Feature: Consistent WAV PCM recording format across all platforms.
 
-[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-stream@2.0.0...HEAD
+[unreleased]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-stream@2.1.0...HEAD
+[2.1.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-stream@2.0.1...@siteed/expo-audio-stream@2.1.0
+[2.0.1]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-stream@2.0.0...@siteed/expo-audio-stream@2.0.1
 [2.0.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-stream@1.17.0...@siteed/expo-audio-stream@2.0.0
 [1.17.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-stream@1.16.0...@siteed/expo-audio-stream@1.17.0
 [1.16.0]: https://github.com/deeeed/expo-audio-stream/compare/@siteed/expo-audio-stream@1.15.1...@siteed/expo-audio-stream@1.16.0

package/README.md

@@ -48,16 +48,217 @@
 - Background audio recording on iOS.
 - Audio features extraction during recording.
 - Consistent WAV PCM recording format across all platforms.
-- Keep recording acrtive while app is in background
+- Keep recording active while app is in background
 - Rich notification system for recording status:
   - Android: Live waveform visualization in notifications
   - Android: Fully customizable notification appearance and actions
   - iOS: Media player integration
+- Advanced audio analysis capabilities:
+  - Mel spectrogram generation for machine learning and visualization
+  - Comprehensive audio feature extraction (MFCC, spectral features, etc.)
+  - Lightweight waveform preview generation
+- Precision audio manipulation:
+  - Advanced audio splitting and trimming API
+  - Support for trimming multiple segments in a single operation
+  - Ability to keep or remove specific time ranges
+- Complete ecosystem:
+  - Full-featured AudioPlayground application showcasing advanced API usage
+  - Ready-to-use UI components via [@siteed/expo-audio-ui](https://github.com/deeeed/expo-audio-stream/tree/main/packages/expo-audio-ui) package
+  - Visualizations, waveforms, and audio controls that can be directly incorporated into your app
+
+## Audio Analysis Features
+
+Extract powerful audio features for advanced audio processing and visualization:
+
+```typescript
+// Extract audio analysis with specific features enabled
+const analysis = await extractAudioAnalysis({
+  fileUri: 'path/to/recording.wav',
+  features: {
+    energy: true,     // Overall energy of the audio
+    rms: true,        // Root mean square (amplitude)
+    zcr: true,        // Zero-crossing rate
+    mfcc: true,       // Mel-frequency cepstral coefficients
+    spectralCentroid: true,  // Brightness of sound
+    tempo: true,      // Estimated BPM
+  }
+});
+```
+
+### Available Audio Features
+
+- **Basic Analysis**: RMS, energy, amplitude range, zero-crossing rate
+- **Spectral Features**: Spectral centroid, flatness, rolloff, bandwidth
+- **Advanced Analysis**: 
+  - MFCC (Mel-frequency cepstral coefficients)
+  - Chromagram (pitch class representation)
+  - Mel Spectrogram
+  - Harmonics-to-noise ratio
+  - Tempo estimation
+  - Pitch detection
+
+### Use Cases
+
+- Visualize audio waveforms with detailed metrics
+- Implement speech recognition preprocessing
+- Create music analysis applications
+- Build audio fingerprinting systems
+- Develop voice activity detection
+
+## API Overview
+
+The library provides several specialized APIs for different audio processing needs:
+
+### Recording and Playback
+
+- **useAudioRecorder**: Hook for recording audio with configurable quality settings
+- **AudioRecorderProvider**: Context provider for sharing recording state across components
+- **useSharedAudioRecorder**: Hook to access shared recording state from any component
+
+```typescript
+// Start a new recording with configuration
+const { startRecording, stopRecording, isRecording, recordingUri } = useAudioRecorder({
+  audioQuality: 'high',
+  sampleRate: 44100,
+  numberOfChannels: 2,
+  bitDepth: 16,
+  outputFormat: 'wav',
+});
+
+// Share recording state across components
+const AudioApp = () => (
+  <AudioRecorderProvider>
+    <RecordButton />
+    <AudioVisualizer />
+  </AudioRecorderProvider>
+);
+```
+
+### Audio Analysis
+
+- **extractAudioAnalysis**: Extract comprehensive audio features for detailed analysis
+- **extractPreview**: Generate lightweight waveform data for visualization
+- **extractAudioData**: Extract raw PCM data for custom processing
+- **extractRawWavAnalysis**: Analyze WAV files without decoding, preserving original PCM values
+
+```typescript
+// Extract detailed audio analysis with feature extraction
+const analysis = await extractAudioAnalysis({
+  fileUri: 'path/to/recording.wav',
+  features: { rms: true, zcr: true, mfcc: true }
+});
+
+// Generate a lightweight waveform preview
+const preview = await extractPreview({
+  fileUri: 'path/to/recording.wav',
+  pointsPerSecond: 50
+});
+
+// Extract raw PCM data for custom processing
+const audioData = await extractAudioData({
+  fileUri: 'path/to/recording.wav',
+  includeWavHeader: true
+});
+```
+
+#### Choosing the Right Audio Analysis Method
+
+| Method | Purpose | Performance | Use When |
+|--------|---------|-------------|----------|
+| `extractAudioAnalysis` | Comprehensive audio feature extraction | Medium-Heavy | You need detailed audio features like MFCC, spectral features |
+| `extractPreview` | Lightweight waveform visualization | Very Light | You only need amplitude data for visualization |
+| `extractAudioData` | Raw PCM data extraction | Medium | You need the raw audio data for custom processing |
+| `extractRawWavAnalysis` | WAV analysis without decoding | Light | You want to analyze WAV files while preserving original values |
+| `extractMelSpectrogram` | Mel spectrogram generation | Heavy | You need frequency-domain representation for ML or visualization |
+
+### Specialized Audio Processing
+
+- **extractMelSpectrogram**: Generate mel spectrogram for audio visualization or ML models
+- **trimAudio**: Trim audio files with precision, supporting multiple segments and formats
+
+```typescript
+// Generate mel spectrogram for audio visualization or ML models
+const melSpectrogram = await extractMelSpectrogram({
+  fileUri: 'path/to/recording.wav',
+  windowSizeMs: 25,
+  hopLengthMs: 10,
+  nMels: 40
+});
+
+// Trim audio files with precision
+const trimmedAudio = await trimAudio({
+  fileUri: 'path/to/recording.wav',
+  startTimeMs: 1000,
+  endTimeMs: 5000,
+  outputFormat: { format: 'wav' }
+});
+
+// Trim multiple segments from an audio file
+const compiledAudio = await trimAudio({
+  fileUri: 'path/to/recording.wav',
+  mode: 'keep',
+  ranges: [
+    { startTimeMs: 1000, endTimeMs: 5000 },
+    { startTimeMs: 10000, endTimeMs: 15000 }
+  ]
+});
+```
+
+### Utility Functions
+
+- **convertPCMToFloat32**: Convert PCM data to Float32Array for processing
+- **getWavFileInfo**: Extract metadata from WAV files
+- **writeWavHeader**: Create WAV headers for raw PCM data
+
+### Low-Level Access
+
+For advanced use cases, the library provides direct access to the native module:
+
+```typescript
+import { ExpoAudioStreamModule } from '@siteed/expo-audio-stream';
+
+// Access platform-specific functionality
+const status = await ExpoAudioStreamModule.status();
+const permissions = await ExpoAudioStreamModule.getPermissionsAsync();
+```
 
 ## Documentation
 
 For detailed documentation, please refer to the [Getting Started Guide](https://deeeed.github.io/expo-audio-stream/docs/).
 
+## Companion Resources
+
+### AudioPlayground Application
+
+The repository includes a complete AudioPlayground application that demonstrates advanced usage of the API. This playground serves as both a demonstration and a learning resource:
+
+- Interactive examples of all major API features
+- Real-time audio visualization and analysis
+- Code samples you can directly reference for your own implementation
+
+Try it online at [https://deeeed.github.io/expo-audio-stream/playground](https://deeeed.github.io/expo-audio-stream/playground) or run it locally from the repository.
+
+### UI Components Package
+
+The [@siteed/expo-audio-ui](https://github.com/deeeed/expo-audio-stream/tree/main/packages/expo-audio-ui) package provides ready-to-use UI components for audio applications:
+
+```bash
+# Install the UI components package
+npm install @siteed/expo-audio-ui
+
+# or with yarn
+yarn add @siteed/expo-audio-ui
+```
+
+This package includes:
+- Waveform visualizers
+- Audio recording controls
+- Playback components
+- Spectrogram displays
+- And more!
+
+All components are built with React Native, Reanimated, and Skia for optimal performance across platforms.
+
 ## License
 
 This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

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

@@ -1,4 +1,5 @@
 // packages/expo-audio-stream/android/src/main/java/net/siteed/audiostream/AudioProcessor.kt
+// packages/expo-audio-stream/android/src/main/java/net/siteed/audiostream/AudioProcessor.kt
 package net.siteed.audiostream
 
 import java.nio.ByteBuffer
@@ -22,6 +23,12 @@ data class DecodingConfig(
     val normalizeAudio: Boolean = false    // Whether to normalize audio levels
 )
 
+data class SpectrogramData(
+    val spectrogram: Array<FloatArray>, // 2D array: [time, frequency]
+    val timeStamps: FloatArray,         // Time (in seconds) for each frame
+    val frequencies: FloatArray         // Frequencies (in Hz) for each mel bin
+)
+
 class AudioProcessor(private val filesDir: File) {
     companion object {
         const val DCT_SQRT_DIVISOR = 2.0
@@ -998,7 +1005,7 @@ class AudioProcessor(private val filesDir: File) {
         return a + fraction * (b - a)
     }
 
-    private fun processAudio(
+    fun processAudio(
         pcmData: ByteArray,
         originalSampleRate: Int,
         targetSampleRate: Int?,
@@ -1625,6 +1632,187 @@ class AudioProcessor(private val filesDir: File) {
         return output
     }
 
+    // Generate a Hann window of a specific size (new, avoids modifying applyHannWindow)
+    private fun generateHannWindow(size: Int): FloatArray {
+        return FloatArray(size) { i ->
+            0.5f * (1f - cos(2f * PI.toFloat() * i / (size - 1)))
+        }
+    }
+
+    // Main function to extract mel spectrogram
+    fun extractMelSpectrogram(
+        audioData: AudioData,
+        windowSizeMs: Float = 25f, // Default 25ms window
+        hopLengthMs: Float = 10f, // Default 10ms hop
+        nMels: Int = 128,         // Number of mel bins
+        fftLength: Int = 2048,    // FFT size
+        fMin: Float = 0f,         // Minimum frequency
+        fMax: Float = audioData.sampleRate.toFloat() / 2, // Nyquist frequency
+        windowType: String = "hann", // Add parameter
+        logScaling: Boolean = true, // Apply log scaling
+        normalize: Boolean = false  // Normalize output
+    ): SpectrogramData {
+        val sampleRate = audioData.sampleRate.toFloat()
+        val samples = convertToFloatArray(audioData.data, audioData.bitDepth)
+
+        // Convert ms to samples
+        val windowSizeSamples = (windowSizeMs * sampleRate / 1000).toInt()
+        val hopLengthSamples = (hopLengthMs * sampleRate / 1000).toInt()
+
+
+        val window = when (windowType.lowercase()) {
+            "hann" -> generateHannWindow(windowSizeSamples)
+            "hamming" -> FloatArray(windowSizeSamples) { i ->
+                0.54f - 0.46f * cos(2f * PI.toFloat() * i / (windowSizeSamples - 1))
+            }
+            else -> throw IllegalArgumentException("Unsupported windowType: $windowType")
+        }
+
+        // Compute STFT
+        val stft = computeSTFT(samples, fftLength, windowSizeSamples, hopLengthSamples, window)
+
+        // Apply mel filterbank
+        val melSpectrogram = applyMelFilterbank(stft, sampleRate, nMels, fftLength, fMin, fMax)
+
+        // Post-processing: log scaling and normalization
+        if (logScaling) {
+            for (i in melSpectrogram.indices) {
+                for (j in melSpectrogram[i].indices) {
+                    melSpectrogram[i][j] = ln(max(1e-10f, melSpectrogram[i][j])).toFloat()
+                }
+            }
+        }
+        if (normalize) {
+            // Find min and max values across the entire spectrogram
+            var minVal = Float.MAX_VALUE
+            var maxVal = Float.MIN_VALUE
+            
+            for (i in melSpectrogram.indices) {
+                for (j in melSpectrogram[i].indices) {
+                    val value = melSpectrogram[i][j]
+                    if (value < minVal) minVal = value
+                    if (value > maxVal) maxVal = value
+                }
+            }
+            
+            val range = maxVal - minVal
+            if (range > 0) {
+                for (i in melSpectrogram.indices) {
+                    for (j in melSpectrogram[i].indices) {
+                        melSpectrogram[i][j] = (melSpectrogram[i][j] - minVal) / range
+                    }
+                }
+            }
+        }
+
+        // Compute timestamps and frequencies for metadata
+        val numFrames = melSpectrogram.size
+        val timeStamps = FloatArray(numFrames) { it * hopLengthMs / 1000f }
+        val frequencies = melFrequencies(nMels, fMin, fMax)
+
+        return SpectrogramData(melSpectrogram, timeStamps, frequencies)
+    }
+
+    // Compute Short-Time Fourier Transform
+    private fun computeSTFT(
+        samples: FloatArray,
+        fftLength: Int,
+        windowSize: Int,
+        hopLength: Int,
+        window: FloatArray
+    ): Array<FloatArray> {
+        val fft = FFT(fftLength)
+        val numFrames = ((samples.size - windowSize) / hopLength) + 1
+        val stft = Array(numFrames) { FloatArray(fftLength / 2 + 1) }
+
+        for (frameIdx in 0 until numFrames) {
+            val start = frameIdx * hopLength
+            val end = minOf(start + windowSize, samples.size)
+            val frame = FloatArray(fftLength) { 0f }
+
+            // Extract and window the frame
+            for (i in start until end) {
+                frame[i - start] = samples[i] * window[i - start]
+            }
+
+            // Compute FFT and power spectrum
+            val fftResult = fft.processSegment(frame)
+            for (i in 0 until fftLength / 2 + 1) {
+                // Check bounds before accessing array elements
+                val real = if (2 * i < fftResult.size) fftResult[2 * i] else 0f
+                val imag = if (2 * i + 1 < fftResult.size) fftResult[2 * i + 1] else 0f
+                stft[frameIdx][i] = real * real + imag * imag
+            }
+        }
+        return stft
+    }
+
+    // Apply mel filterbank to STFT
+    private fun applyMelFilterbank(
+        stft: Array<FloatArray>,
+        sampleRate: Float,
+        nMels: Int,
+        fftLength: Int,
+        fMin: Float,
+        fMax: Float
+    ): Array<FloatArray> {
+        val numFrames = stft.size
+        val numBins = stft[0].size
+        val melFilters = createMelFilterbank(sampleRate, fftLength, nMels, fMin, fMax)
+        val melSpectrogram = Array(numFrames) { FloatArray(nMels) }
+
+        for (frame in 0 until numFrames) {
+            for (melBin in 0 until nMels) {
+                var sum = 0f
+                for (bin in 0 until numBins) {
+                    sum += stft[frame][bin] * melFilters[melBin][bin]
+                }
+                melSpectrogram[frame][melBin] = sum
+            }
+        }
+        return melSpectrogram
+    }
+
+    // Create mel filterbank matrix
+    private fun createMelFilterbank(
+        sampleRate: Float,
+        fftLength: Int,
+        nMels: Int,
+        fMin: Float,
+        fMax: Float
+    ): Array<FloatArray> {
+        val freqs = FloatArray(fftLength / 2 + 1) { it * sampleRate / fftLength }
+        val melPoints = melFrequencies(nMels + 2, fMin, fMax)
+        val melFilters = Array(nMels) { FloatArray(fftLength / 2 + 1) }
+
+        for (melIdx in 0 until nMels) {
+            val fLow = melPoints[melIdx]
+            val fCenter = melPoints[melIdx + 1]
+            val fHigh = melPoints[melIdx + 2]
+
+            for (bin in freqs.indices) {
+                val freq = freqs[bin]
+                melFilters[melIdx][bin] = when {
+                    freq < fLow || freq > fHigh -> 0f
+                    freq <= fCenter -> (freq - fLow) / (fCenter - fLow)
+                    else -> (fHigh - freq) / (fHigh - fCenter)
+                }
+            }
+        }
+        return melFilters
+    }
+
+    // Generate mel-spaced frequencies
+    private fun melFrequencies(nMels: Int, fMin: Float, fMax: Float): FloatArray {
+        val melMin = hzToMel(fMin)
+        val melMax = hzToMel(fMax)
+        val melPoints = FloatArray(nMels) { i ->
+            val mel = melMin + i * (melMax - melMin) / (nMels - 1)
+            melToHz(mel)
+        }
+        return melPoints
+    }
+
     private fun computeMelSpectrogram(samples: FloatArray, sampleRate: Float): List<Float> {
         val (powerSpectrum, _) = prepareFFT(samples, sampleRate)
         val melFilters = computeMelFilterbank(
@@ -1933,4 +2121,115 @@ class AudioProcessor(private val filesDir: File) {
             return null
         }
     }
+
+    /**
+     * Decodes a specific time range of an audio file directly to PCM data
+     * This is more efficient than decoding the entire file when only a portion is needed
+     */
+    fun decodeAudioRangeToPCM(fileUri: String, startTimeMs: Long, endTimeMs: Long): AudioData? {
+        val extractor = MediaExtractor()
+        var decoder: android.media.MediaCodec? = null
+        
+        try {
+            extractor.setDataSource(fileUri)
+            val trackIndex = (0 until extractor.trackCount).find { 
+                extractor.getTrackFormat(it).getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true 
+            } ?: return null
+            
+            extractor.selectTrack(trackIndex)
+            val format = extractor.getTrackFormat(trackIndex)
+            
+            val sampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+            val channels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+            decoder = android.media.MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!)
+            decoder.configure(format, null, null, 0)
+            decoder.start()
+
+            extractor.seekTo(startTimeMs * 1000, MediaExtractor.SEEK_TO_PREVIOUS_SYNC)
+            val pcmData = mutableListOf<Byte>()
+            val bufferInfo = android.media.MediaCodec.BufferInfo()
+            var isEOS = false
+            var firstBufferTimeUs: Long? = null
+
+            while (!isEOS) {
+                val inputBufferId = decoder.dequeueInputBuffer(10000)
+                if (inputBufferId >= 0) {
+                    val inputBuffer = decoder.getInputBuffer(inputBufferId)!!
+                    val sampleSize = extractor.readSampleData(inputBuffer, 0)
+                    if (sampleSize < 0 || extractor.sampleTime > endTimeMs * 1000) {
+                        decoder.queueInputBuffer(inputBufferId, 0, 0, 0, android.media.MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                        isEOS = true
+                    } else {
+                        decoder.queueInputBuffer(inputBufferId, 0, sampleSize, extractor.sampleTime, 0)
+                        extractor.advance()
+                    }
+                }
+
+                val outputBufferId = decoder.dequeueOutputBuffer(bufferInfo, 10000)
+                if (outputBufferId >= 0) {
+                    val outputBuffer = decoder.getOutputBuffer(outputBufferId)!!
+                    if (firstBufferTimeUs == null) firstBufferTimeUs = bufferInfo.presentationTimeUs
+                    val chunk = ByteArray(bufferInfo.size)
+                    outputBuffer.get(chunk)
+                    pcmData.addAll(chunk.toList())
+                    decoder.releaseOutputBuffer(outputBufferId, false)
+                }
+            }
+
+            // If we didn't get any data or first buffer time, return null
+            if (pcmData.isEmpty() || firstBufferTimeUs == null) {
+                return null
+            }
+
+            // Trim PCM data to exact time range
+            val bytesPerSample = 2 // 16-bit PCM
+            val bytesPerFrame = bytesPerSample * channels
+            val samplesPerSecond = sampleRate * channels
+            val dt = 1_000_000.0 / sampleRate // Time per sample in microseconds
+            
+            val allSamples = java.nio.ByteBuffer.wrap(pcmData.toByteArray()).order(java.nio.ByteOrder.LITTLE_ENDIAN).asShortBuffer()
+            val totalSamples = allSamples.capacity()
+            
+            // Calculate sample indices for the exact time range
+            val startSample = ((startTimeMs * 1000 - firstBufferTimeUs) / dt).toInt().coerceIn(0, totalSamples)
+            val endSample = ((endTimeMs * 1000 - firstBufferTimeUs) / dt).toInt().coerceIn(startSample, totalSamples)
+            
+            // Create a new ShortBuffer view starting at the correct position
+            allSamples.position(startSample)
+            val trimmedSamples = ShortArray(endSample - startSample)
+            for (i in trimmedSamples.indices) {
+                trimmedSamples[i] = allSamples.get()
+            }
+            
+            // Convert ShortArray to ByteArray
+            val trimmedBytes = ByteArray(trimmedSamples.size * 2)
+            val byteBuffer = java.nio.ByteBuffer.wrap(trimmedBytes).order(java.nio.ByteOrder.LITTLE_ENDIAN)
+            val shortBuffer = byteBuffer.asShortBuffer()
+            shortBuffer.put(trimmedSamples)
+
+            return AudioData(
+                data = trimmedBytes,
+                sampleRate = sampleRate,
+                channels = channels,
+                bitDepth = 16, // MediaCodec typically decodes to 16-bit PCM
+                durationMs = endTimeMs - startTimeMs
+            )
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Failed to decode audio range: ${e.message}", e)
+            return null
+        } finally {
+            try {
+                decoder?.stop()
+                decoder?.release()
+            } catch (e: Exception) {
+                Log.w(Constants.TAG, "Error releasing decoder: ${e.message}")
+            }
+            
+            try {
+                extractor.release()
+            } catch (e: Exception) {
+                Log.w(Constants.TAG, "Error releasing extractor: ${e.message}")
+            }
+        }
+    }
 }

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

@@ -11,8 +11,6 @@ import android.os.Looper
 import expo.modules.kotlin.Promise
 import android.app.NotificationChannel
 import android.app.NotificationManager
-import android.os.Build.VERSION_CODES
-import android.app.Notification
 import androidx.core.app.NotificationCompat
 
 class AudioRecordingService : Service() {
@@ -27,6 +25,8 @@ class AudioRecordingService : Service() {
     override fun onCreate() {
         super.onCreate()
         Log.d(Constants.TAG, "AudioRecordingService onCreate")
+        isRunning = true
+        setServiceRunning(true)
     }
 
     override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
@@ -84,6 +84,7 @@ class AudioRecordingService : Service() {
         stopForeground(STOP_FOREGROUND_REMOVE)
 
         isRunning = false
+        setServiceRunning(false)
         super.onDestroy()
     }
 
@@ -122,6 +123,17 @@ class AudioRecordingService : Service() {
     }
 
     companion object {
+        // Static flag to track if service is running
+        private var isServiceRunningStatic = false
+
+        fun isServiceRunning(): Boolean {
+            return isServiceRunningStatic
+        }
+
+        fun setServiceRunning(running: Boolean) {
+            isServiceRunningStatic = running
+        }
+
         fun startService(context: Context) {
             val serviceIntent = Intent(context, AudioRecordingService::class.java)
             if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
@@ -129,10 +141,12 @@ class AudioRecordingService : Service() {
             } else {
                 context.startService(serviceIntent)
             }
+            setServiceRunning(true)
         }
 
         fun stopService(context: Context) {
             context.stopService(Intent(context, AudioRecordingService::class.java))
+            setServiceRunning(false)
         }
     }
 }