@siteed/expo-audio-stream 1.12.2 → 1.13.0

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

@@ -9,6 +9,19 @@ import java.io.File
 import java.io.IOException
 import java.util.concurrent.atomic.AtomicLong
 import kotlin.system.measureTimeMillis
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import android.media.MediaCodec
+import java.io.FileInputStream
+import java.nio.channels.FileChannel
+import java.io.RandomAccessFile
+
+data class DecodingConfig(
+    val targetSampleRate: Int? = null,     // Optional target sample rate
+    val targetChannels: Int? = null,       // Optional target number of channels
+    val targetBitDepth: Int = 16,          // Default to 16-bit PCM
+    val normalizeAudio: Boolean = false    // Whether to normalize audio levels
+)
 
 class AudioProcessor(private val filesDir: File) {
     companion object {
@@ -27,103 +40,142 @@ class AudioProcessor(private val filesDir: File) {
         }
     }
 
-    data class AudioData(val data: ByteArray, val sampleRate: Int, val bitDepth: Int, val channels: Int)
+    data class AudioData(val data: ByteArray, val sampleRate: Int, val bitDepth: Int, val channels: Int, val durationMs: Long = 0)
 
     private var cumulativeMinAmplitude = Float.MAX_VALUE
     private var cumulativeMaxAmplitude = Float.NEGATIVE_INFINITY
 
-
-    fun loadAudioFile(originalFileUri: String, skipWavHeader: Boolean = false): AudioData? {
-        // Remove the file:// prefix if present
-        val fileUri = originalFileUri.removePrefix("file://")
-        var file = File(fileUri)
-
-        // Check if the file exists at the provided fileUri
-        if (!file.exists()) {
-            // Fallback to filesDir if the file does not exist at fileUri
-            file = File(filesDir, file.name)
-            if (!file.exists()) {
-                Log.e("AudioProcessor", "File does not exist at provided path or in filesDir: $fileUri")
-                return null
-            }
-        }
-
-        // Check if the file has a valid extension
-        val validExtensions = listOf("wav", "pcm")
-        val fileExtension = file.extension.lowercase()
-        if (fileExtension !in validExtensions) {
-            Log.e("AudioProcessor", "Invalid file extension: $fileExtension. Supported extensions are: $validExtensions")
-            return null
-        }
-
+    fun loadAudioFile(filePath: String, debug: Boolean = false): AudioData? {
         try {
-            val fileData = file.readBytes()
+            val fileUri = filePath.removePrefix("file://")
+            Log.d("AudioProcessor", "Processing WAV file: $fileUri")
 
-            if (fileData.size < Constants.WAV_HEADER_SIZE) {
-                Log.e("AudioProcessor", "File is too small to be a valid WAV file")
-                return null
-            }
+            val file = File(fileUri).takeIf { it.exists() } ?: File(filesDir, File(fileUri).name).takeIf { it.exists() }
+                ?: run {
+                    Log.e("AudioProcessor", "File not found: $fileUri")
+                    return null
+                }
 
-            // Read the WAV header
-            val riffHeader = String(fileData.sliceArray(0..3))
-            if (riffHeader != "RIFF") {
+            val raf = RandomAccessFile(file, "r")
+            val fileSize = raf.length()
+            
+            // Read RIFF header
+            val riffHeader = ByteArray(4).apply { raf.readFully(this) }
+            if (String(riffHeader) != "RIFF") {
                 Log.e("AudioProcessor", "Invalid RIFF header")
                 return null
             }
 
-            val format = String(fileData.sliceArray(8..11))
-            if (format != "WAVE") {
-                Log.e("AudioProcessor", "Invalid WAVE format")
+            // Read file size (4 bytes little-endian)
+            val fileSizeBytes = ByteArray(4).apply { raf.readFully(this) }
+            val expectedFileSize = ByteBuffer.wrap(fileSizeBytes).order(ByteOrder.LITTLE_ENDIAN).int + 8L
+
+            // Read WAVE header
+            val waveHeader = ByteArray(4).apply { raf.readFully(this) }
+            if (String(waveHeader) != "WAVE") {
+                Log.e("AudioProcessor", "Invalid WAVE header")
                 return null
             }
 
-            var offset = 12
-            var dataSize = 0
+            var fmtChunkFound = false
+            var dataChunkFound = false
             var sampleRate = 0
             var channels = 0
             var bitDepth = 0
+            var dataOffset = 0L
+            var dataSize = 0L
+
+            // Parse chunks
+            while (raf.filePointer < fileSize - 8) {
+                val chunkId = ByteArray(4).apply { raf.readFully(this) }.toString(Charsets.UTF_8)
+                val chunkSizeBytes = ByteArray(4).apply { raf.readFully(this) }
+                val chunkSize = ByteBuffer.wrap(chunkSizeBytes).order(ByteOrder.LITTLE_ENDIAN).int.toLong() and 0xFFFFFFFFL
 
-            // Parse chunks until we find the 'data' chunk
-            while (offset < fileData.size - 8) {
-                val chunkId = String(fileData.sliceArray(offset until offset + 4))
-                val chunkSize = ByteBuffer.wrap(fileData.sliceArray(offset + 4 until offset + 8)).order(ByteOrder.LITTLE_ENDIAN).int
+                Log.d("AudioProcessor", "Found chunk: $chunkId ($chunkSize bytes)")
 
                 when (chunkId) {
                     "fmt " -> {
-                        channels = ByteBuffer.wrap(fileData.sliceArray(offset + 10 until offset + 12)).order(ByteOrder.LITTLE_ENDIAN).short.toInt()
-                        sampleRate = ByteBuffer.wrap(fileData.sliceArray(offset + 12 until offset + 16)).order(ByteOrder.LITTLE_ENDIAN).int
-                        bitDepth = ByteBuffer.wrap(fileData.sliceArray(offset + 22 until offset + 24)).order(ByteOrder.LITTLE_ENDIAN).short.toInt()
+                        if (chunkSize < 16) {
+                            Log.e("AudioProcessor", "Invalid fmt chunk size")
+                            return null
+                        }
+                        
+                        val formatData = ByteArray(16)
+                        raf.readFully(formatData)
+                        val formatBuffer = ByteBuffer.wrap(formatData).order(ByteOrder.LITTLE_ENDIAN)
+                        
+                        val audioFormat = formatBuffer.short // Skip audio format
+                        channels = formatBuffer.short.toInt() and 0xFFFF
+                        sampleRate = formatBuffer.int
+                        val byteRate = formatBuffer.int
+                        val blockAlign = formatBuffer.short
+                        bitDepth = formatBuffer.short.toInt() and 0xFFFF
+                        
+                        Log.d("AudioProcessor", "Raw format data: ${formatData.joinToString(", ")}")
+                        Log.d("AudioProcessor", "Format chunk: audioFormat=$audioFormat, channels=$channels, sampleRate=$sampleRate, bitDepth=$bitDepth, byteRate=$byteRate, blockAlign=$blockAlign")
+                        
+                        if (bitDepth !in listOf(8, 16, 32)) {
+                            Log.e("AudioProcessor", "Invalid bit depth: $bitDepth")
+                            return null
+                        }
+                        
+                        val remainingFmtBytes = chunkSize - 16
+                        if (remainingFmtBytes > 0) {
+                            raf.skipBytes(remainingFmtBytes.toInt())
+                        }
+                        fmtChunkFound = true
                     }
                     "data" -> {
+                        dataOffset = raf.filePointer
                         dataSize = chunkSize
-                        offset += 8 // Skip chunk ID and size
+                        dataChunkFound = true
                         break
                     }
+                    else -> {
+                        // Skip unknown chunks
+                        val skipBytes = chunkSize
+                        if (skipBytes > 0) {
+                            val actualSkip = minOf(skipBytes, fileSize - raf.filePointer)
+                            raf.seek(raf.filePointer + actualSkip)
+                        }
+                    }
                 }
-
-                offset += chunkSize + 8 // Move to the next chunk
             }
 
-            if (dataSize == 0) {
-                Log.e("AudioProcessor", "No data chunk found in WAV file")
+            if (!fmtChunkFound || !dataChunkFound) {
+                Log.e("AudioProcessor", "Missing essential chunks (fmt=$fmtChunkFound, data=$dataChunkFound)")
                 return null
             }
 
-            val audioData = if (skipWavHeader) {
-                fileData.sliceArray(offset until offset + dataSize)
-            } else {
-                fileData
+            // Calculate actual data size if it seems wrong
+            if (dataSize <= 0 || dataSize > fileSize - dataOffset) {
+                dataSize = fileSize - dataOffset
+                Log.d("AudioProcessor", "Adjusted data size to: $dataSize")
             }
 
-            return AudioData(audioData, sampleRate, bitDepth.toInt(), channels.toInt())
-        } catch (e: IOException) {
-            Log.e("AudioProcessor", "Failed to load audio file: ${e.message}", e)
-            return null
-        } catch (e: IllegalArgumentException) {
-            Log.e("AudioProcessor", "Invalid audio file format: ${e.message}", e)
-            return null
+            Log.d("AudioProcessor", "Reading PCM data: offset=$dataOffset, size=$dataSize")
+            
+            val wavData = ByteArray(dataSize.toInt())
+            raf.seek(dataOffset)
+            raf.readFully(wavData)
+
+            // Calculate duration in ms
+            // Each sample is bitsPerSample/8 bytes, and we have 'channels' samples per frame
+            val bytesPerFrame = channels * (bitDepth / 8)
+            val numFrames = wavData.size / bytesPerFrame
+            val durationMs = (numFrames * 1000L) / sampleRate
+
+            Log.d(Constants.TAG, "WAV duration calculation: size=${wavData.size}, bytesPerFrame=$bytesPerFrame, numFrames=$numFrames, sampleRate=$sampleRate, duration=${durationMs}ms")
+
+            return AudioData(
+                data = wavData,
+                sampleRate = sampleRate,
+                channels = channels,
+                bitDepth = bitDepth,
+                durationMs = durationMs
+            )
         } catch (e: Exception) {
-            Log.e("AudioProcessor", "Unexpected error: ${e.message}", e)
+            Log.e(Constants.TAG, "Failed to load WAV file: ${e.message}")
             return null
         }
     }
@@ -249,7 +301,6 @@ class AudioProcessor(private val filesDir: File) {
         )
     }
 
-
     fun resetCumulativeAmplitudeRange() {
         cumulativeMinAmplitude = Float.MAX_VALUE
         cumulativeMaxAmplitude = Float.MIN_VALUE
@@ -280,8 +331,6 @@ class AudioProcessor(private val filesDir: File) {
         }
     }
 
-
-
     /**
      * Computes the features of the audio data.
      * @param segmentData The segment data.
@@ -445,8 +494,6 @@ class AudioProcessor(private val filesDir: File) {
         }
     }
 
-
-
     /**
      * Computes the Mel filter bank.
      * @param numFilters The number of Mel filters.
@@ -482,7 +529,6 @@ class AudioProcessor(private val filesDir: File) {
         return melFilters
     }
 
-
     /**
      * Computes the Discrete Cosine Transform (DCT) of the log energies.
      * @param logEnergies The log energies.
@@ -504,7 +550,6 @@ class AudioProcessor(private val filesDir: File) {
         return dct.toList()
     }
 
-
     /**
      * Extracts the spectral centroid from the audio data.
      * @param segmentData The segment data.
@@ -520,7 +565,6 @@ class AudioProcessor(private val filesDir: File) {
         return (weightedSum / sum) * (sampleRate / 2) / magnitudeSpectrum.size
     }
 
-
     /**
      * Extracts the spectral flatness from the audio data.
      * @param segmentData The segment data.
@@ -687,4 +731,756 @@ class AudioProcessor(private val filesDir: File) {
         // Compute the HNR
         return if (autocorrelation[0] != 0f) 10 * log10(maxAutocorrelation / (autocorrelation[0] - maxAutocorrelation)) else 0f
     }
+
+    fun loadAudioFromAnyFormat(fileUri: String, decodingConfig: DecodingConfig? = null): AudioData? {
+        val cleanUri = fileUri.removePrefix("file://")
+        val file = File(cleanUri).takeIf { it.exists() } ?: File(filesDir, File(cleanUri).name).takeIf { it.exists() }
+            ?: run {
+                Log.e("AudioProcessor", "File not found in any location: $cleanUri")
+                return null
+            }
+
+        // First try MediaExtractor
+        val extractor = MediaExtractor()
+        try {
+            Log.d("AudioProcessor", "Attempting MediaExtractor with path: ${file.absolutePath}")
+            extractor.setDataSource(file.absolutePath)
+            
+            // Find the first audio track
+            val audioTrackIndex = (0 until extractor.trackCount)
+                .find { extractor.getTrackFormat(it).getString(MediaFormat.KEY_MIME)?.startsWith("audio/") == true }
+            
+            if (audioTrackIndex != null) {
+                val format = extractor.getTrackFormat(audioTrackIndex)
+                extractor.selectTrack(audioTrackIndex)
+
+                // Get original audio properties
+                val originalSampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+                val originalChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+                val totalDurationUs = try {
+                    format.getLong(MediaFormat.KEY_DURATION)
+                } catch (e: Exception) {
+                    (format.getString(MediaFormat.KEY_DURATION) ?: "-1").toLong()
+                }
+                Log.d("AudioProcessor", "Raw duration from format: ${totalDurationUs}us")
+                
+                val totalDurationMs = totalDurationUs / 1000
+                Log.d("AudioProcessor", "Final duration: ${totalDurationMs}ms")
+
+                // Process using MediaExtractor
+                val pcmData = decodeAudioToPCM(extractor, format)
+                val processedData = if (decodingConfig != null) {
+                    processAudio(
+                        pcmData,
+                        originalSampleRate,
+                        decodingConfig.targetSampleRate,
+                        originalChannels,
+                        decodingConfig.targetChannels,
+                        decodingConfig.normalizeAudio
+                    )
+                } else {
+                    pcmData
+                }
+
+                return AudioData(
+                    data = processedData,
+                    sampleRate = decodingConfig?.targetSampleRate ?: originalSampleRate,
+                    bitDepth = decodingConfig?.targetBitDepth ?: 16,
+                    channels = decodingConfig?.targetChannels ?: originalChannels,
+                    durationMs = totalDurationMs  // Pass through the duration
+                )
+            }
+        } catch (e: Exception) {
+            Log.d("AudioProcessor", "MediaExtractor failed, attempting WAV parser: ${e.message}")
+        } finally {
+            extractor.release()
+        }
+
+        // If MediaExtractor failed and file is WAV, try WAV parser
+        if (file.name.lowercase().endsWith(".wav")) {
+            Log.d("AudioProcessor", "Falling back to WAV parser")
+            return loadAudioFile(file.absolutePath, false)?.let { wavData ->
+                if (decodingConfig != null) {
+                    val processedData = processAudio(
+                        wavData.data,
+                        wavData.sampleRate,
+                        decodingConfig.targetSampleRate,
+                        wavData.channels,
+                        decodingConfig.targetChannels,
+                        decodingConfig.normalizeAudio
+                    )
+                    AudioData(
+                        data = processedData,
+                        sampleRate = decodingConfig.targetSampleRate ?: wavData.sampleRate,
+                        bitDepth = decodingConfig.targetBitDepth,
+                        channels = decodingConfig.targetChannels ?: wavData.channels,
+                        durationMs = wavData.durationMs  // Pass through the duration
+                    )
+                } else {
+                    wavData
+                }
+            }
+        }
+
+        Log.e("AudioProcessor", "Failed to process audio file with both MediaExtractor and WAV parser")
+        return null
+    }
+
+    private fun decodeAudioToPCM(extractor: MediaExtractor, format: MediaFormat): ByteArray {
+        val decoder = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!)
+        decoder.configure(format, null, null, 0)
+        decoder.start()
+
+        val info = MediaCodec.BufferInfo()
+        val pcmData = mutableListOf<Byte>()
+
+        var isEOS = false
+        while (!isEOS) {
+            val inputBufferId = decoder.dequeueInputBuffer(10000)
+            if (inputBufferId >= 0) {
+                val inputBuffer = decoder.getInputBuffer(inputBufferId)!!
+                val sampleSize = extractor.readSampleData(inputBuffer, 0)
+
+                if (sampleSize < 0) {
+                    decoder.queueInputBuffer(inputBufferId, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                    isEOS = true
+                } else {
+                    decoder.queueInputBuffer(inputBufferId, 0, sampleSize, extractor.sampleTime, 0)
+                    extractor.advance()
+                }
+            }
+
+            val outputBufferId = decoder.dequeueOutputBuffer(info, 10000)
+            if (outputBufferId >= 0) {
+                val outputBuffer = decoder.getOutputBuffer(outputBufferId)!!
+                val chunk = ByteArray(info.size)
+                outputBuffer.get(chunk)
+                pcmData.addAll(chunk.toList())
+                decoder.releaseOutputBuffer(outputBufferId, false)
+            }
+        }
+
+        decoder.stop()
+        decoder.release()
+
+        return pcmData.toByteArray()
+    }
+
+    private fun resampleAudio(
+        pcmData: ByteArray,
+        originalSampleRate: Int,
+        targetSampleRate: Int,
+        originalChannels: Int
+    ): ByteArray {
+        // Convert byte array to short array (16-bit samples)
+        val shortArray = ShortArray(pcmData.size / 2)
+        ByteBuffer.wrap(pcmData).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(shortArray)
+
+        // Convert to mono if needed
+        val monoShortArray = if (originalChannels > 1) {
+            convertToMono(shortArray, originalChannels)
+        } else {
+            shortArray
+        }
+
+        // Resample
+        val resampleRatio = targetSampleRate.toDouble() / originalSampleRate
+        val newLength = (monoShortArray.size * resampleRatio).toInt()
+        val resampledArray = ShortArray(newLength)
+
+        for (i in resampledArray.indices) {
+            val originalIndex = (i / resampleRatio).toInt()
+            val nextIndex = minOf(originalIndex + 1, monoShortArray.size - 1)
+            val fraction = (i / resampleRatio) - originalIndex
+
+            // Linear interpolation
+            val sample = linearInterpolate(
+                monoShortArray[originalIndex].toDouble(),
+                monoShortArray[nextIndex].toDouble(),
+                fraction
+            ).toInt().toShort()
+
+            resampledArray[i] = sample
+        }
+
+        // Convert back to byte array
+        val resultBuffer = ByteBuffer.allocate(resampledArray.size * 2)
+        resultBuffer.order(ByteOrder.LITTLE_ENDIAN)
+        resultBuffer.asShortBuffer().put(resampledArray)
+        return resultBuffer.array()
+    }
+
+    private fun convertToMono(stereoData: ShortArray, channels: Int): ShortArray {
+        val monoLength = stereoData.size / channels
+        val monoData = ShortArray(monoLength)
+
+        for (i in 0 until monoLength) {
+            var sum = 0
+            for (ch in 0 until channels) {
+                sum += stereoData[i * channels + ch]
+            }
+            monoData[i] = (sum / channels).toShort()
+        }
+
+        return monoData
+    }
+
+    private fun linearInterpolate(a: Double, b: Double, fraction: Double): Double {
+        return a + fraction * (b - a)
+    }
+
+    private fun processAudio(
+        pcmData: ByteArray,
+        originalSampleRate: Int,
+        targetSampleRate: Int?,
+        originalChannels: Int,
+        targetChannels: Int?,
+        normalize: Boolean
+    ): ByteArray {
+        var processedData = pcmData
+
+        // Only resample if target sample rate is explicitly specified and different
+        if (targetSampleRate != null && originalSampleRate != targetSampleRate) {
+            processedData = resampleAudio(processedData, originalSampleRate, targetSampleRate, originalChannels)
+        }
+
+        // Only convert channels if target channels is explicitly specified and different
+        if (targetChannels != null && originalChannels != targetChannels) {
+            processedData = convertChannels(processedData, originalChannels, targetChannels)
+        }
+
+        // Only normalize if explicitly requested
+        if (normalize) {
+            processedData = normalizeAudio(processedData)
+        }
+
+        return processedData
+    }
+
+    private fun normalizeAudio(pcmData: ByteArray): ByteArray {
+        val shorts = ShortArray(pcmData.size / 2)
+        ByteBuffer.wrap(pcmData).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(shorts)
+
+        // Find maximum amplitude
+        var maxAmplitude = 0
+        for (sample in shorts) {
+            maxAmplitude = maxOf(maxAmplitude, abs(sample.toInt()))
+        }
+
+        // Normalize if we found a non-zero maximum
+        if (maxAmplitude > 0) {
+            val normalizationFactor = Short.MAX_VALUE.toFloat() / maxAmplitude
+            for (i in shorts.indices) {
+                shorts[i] = (shorts[i] * normalizationFactor).toInt().toShort()
+            }
+        }
+
+        // Convert back to bytes
+        val resultBuffer = ByteBuffer.allocate(shorts.size * 2)
+        resultBuffer.order(ByteOrder.LITTLE_ENDIAN)
+        resultBuffer.asShortBuffer().put(shorts)
+        return resultBuffer.array()
+    }
+
+    private fun convertChannels(pcmData: ByteArray, originalChannels: Int, targetChannels: Int): ByteArray {
+        val result = ByteArray(pcmData.size * targetChannels / originalChannels)
+        val inputBuffer = ByteBuffer.wrap(pcmData).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer()
+        val outputBuffer = ByteBuffer.wrap(result).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer()
+
+        for (i in 0 until result.size) {
+            val channelData = ShortArray(targetChannels)
+            for (j in 0 until targetChannels) {
+                channelData[j] = inputBuffer.get()
+            }
+            outputBuffer.put(channelData)
+        }
+
+        return result
+    }
+
+    private fun debugWavHeader(file: File) {
+        try {
+            val bytes = ByteArray(44) // Standard WAV header size
+            RandomAccessFile(file, "r").use { raf ->
+                raf.readFully(bytes)
+            }
+            
+            Log.d("AudioProcessor", "WAV Header Bytes: ${bytes.joinToString(", ") { String.format("%02X", it) }}")
+            Log.d("AudioProcessor", "ASCII: ${bytes.map { it.toInt().toChar() }.joinToString("")}")
+            
+            val buffer = ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN)
+            Log.d("AudioProcessor", """
+                RIFF header: ${String(bytes, 0, 4)}
+                File size: ${buffer.getInt(4)}
+                WAVE header: ${String(bytes, 8, 4)}
+                fmt  header: ${String(bytes, 12, 4)}
+                Chunk size: ${buffer.getInt(16)}
+                Audio format: ${buffer.getShort(20)}
+                Channels: ${buffer.getShort(22)}
+                Sample rate: ${buffer.getInt(24)}
+                Byte rate: ${buffer.getInt(28)}
+                Block align: ${buffer.getShort(32)}
+                Bits per sample: ${buffer.getShort(34)}
+            """.trimIndent())
+        } catch (e: Exception) {
+            Log.e("AudioProcessor", "Failed to debug WAV header: ${e.message}")
+        }
+    }
+
+    fun generatePreview(
+        audioData: AudioData,
+        numberOfPoints: Int,
+        startTimeMs: Long? = null,
+        endTimeMs: Long? = null,
+        config: RecordingConfig
+    ): AudioAnalysisData {
+        val totalDurationMs = audioData.durationMs
+        
+        Log.d(Constants.TAG, "Total audio duration: ${totalDurationMs}ms")
+        
+        // Validate time range
+        if (startTimeMs != null) {
+            require(startTimeMs >= 0) { "startTime must be non-negative, got: $startTimeMs" }
+            require(startTimeMs <= totalDurationMs) { "startTime ($startTimeMs) is beyond audio duration ($totalDurationMs)" }
+        }
+        
+        if (endTimeMs != null) {
+            require(endTimeMs >= 0) { "endTime must be non-negative, got: $endTimeMs" }
+            if (endTimeMs > totalDurationMs) {
+                Log.w(Constants.TAG, "endTime ($endTimeMs) is beyond audio duration ($totalDurationMs), clamping to duration")
+            }
+            if (startTimeMs != null) {
+                require(startTimeMs < endTimeMs) { "startTime ($startTimeMs) must be less than endTime ($endTimeMs)" }
+            }
+        }
+        
+        // Calculate effective range
+        val effectiveStartMs = startTimeMs ?: 0L
+        val effectiveEndMs = (endTimeMs ?: totalDurationMs).coerceAtMost(totalDurationMs)
+        val durationMs = effectiveEndMs - effectiveStartMs
+        
+        Log.d(Constants.TAG, "Preview range: ${effectiveStartMs}ms to ${effectiveEndMs}ms (${durationMs}ms)")
+        
+        // Calculate sample range
+        val startSampleIndex = ((effectiveStartMs * audioData.sampleRate) / 1000).toInt()
+        val endSampleIndex = ((effectiveEndMs * audioData.sampleRate) / 1000).toInt().coerceAtMost(audioData.data.size)
+        val samplesInRange = endSampleIndex - startSampleIndex
+        
+        if (samplesInRange <= 0) {
+            throw IllegalArgumentException("Invalid sample range: contains no samples")
+        }
+        
+        val samplesPerPoint = (samplesInRange / numberOfPoints).coerceAtLeast(1)
+        val pointsPerSecond = numberOfPoints.toDouble() / (durationMs.toDouble() / 1000.0)
+        
+        val dataPoints = mutableListOf<DataPoint>()
+        var minAmplitude = Float.MAX_VALUE
+        var maxAmplitude = Float.MIN_VALUE
+        
+        val extractionTimeMs = measureTimeMillis {
+            for (i in 0 until numberOfPoints) {
+                val pointStartSample = startSampleIndex + (i * samplesPerPoint)
+                val pointEndSample = minOf(startSampleIndex + ((i + 1) * samplesPerPoint), endSampleIndex)
+                
+                if (pointStartSample >= pointEndSample) break
+                
+                try {
+                    val segmentBytes = audioData.data.sliceArray(pointStartSample until pointEndSample)
+                    
+                    // Convert PCM bytes to float samples with proper bit depth handling
+                    val segmentData = when (audioData.bitDepth) {
+                        16 -> convert16BitPcmToFloat(segmentBytes)
+                        32 -> convert32BitPcmToFloat(segmentBytes)
+                        else -> convert8BitPcmToFloat(segmentBytes)
+                    }
+                    
+                    // Calculate time points based on actual sample rate
+                    val startTimePoint = ((pointStartSample * 1000L) / (audioData.sampleRate * audioData.channels)).toFloat()
+                    val endTimePoint = ((pointEndSample * 1000L) / (audioData.sampleRate * audioData.channels)).toFloat()
+                    
+                    val amplitude = when (config.algorithm.lowercase()) {
+                        "peak" -> segmentData.maxOf { abs(it) }
+                        else -> sqrt(segmentData.map { it * it }.average().toFloat())
+                    }
+                    
+                    minAmplitude = minOf(minAmplitude, amplitude)
+                    maxAmplitude = maxOf(maxAmplitude, amplitude)
+                    
+                    dataPoints.add(DataPoint(
+                        id = i.toLong(),
+                        amplitude = amplitude,
+                        startTime = startTimePoint,
+                        endTime = endTimePoint,
+                        startPosition = pointStartSample,
+                        endPosition = pointEndSample,
+                        samples = pointEndSample - pointStartSample
+                    ))
+                } catch (e: Exception) {
+                    Log.e(Constants.TAG, "Error processing segment $i: ${e.message}")
+                    throw IllegalStateException("Failed to process audio segment: ${e.message}", e)
+                }
+            }
+        }
+        
+        if (dataPoints.isEmpty()) {
+            throw IllegalStateException("No data points were generated")
+        }
+        
+        return AudioAnalysisData(
+            pointsPerSecond = pointsPerSecond,
+            durationMs = durationMs.toInt(),
+            bitDepth = audioData.bitDepth,
+            numberOfChannels = audioData.channels,
+            sampleRate = audioData.sampleRate,
+            samples = samplesInRange,
+            dataPoints = dataPoints,
+            amplitudeRange = AudioAnalysisData.AmplitudeRange(minAmplitude, maxAmplitude),
+            speakerChanges = emptyList(),
+            extractionTimeMs = extractionTimeMs.toFloat()
+        )
+    }
+
+    // Add these conversion helpers
+    private fun convert16BitPcmToFloat(bytes: ByteArray): FloatArray {
+        val shorts = ShortArray(bytes.size / 2)
+        ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).asShortBuffer().get(shorts)
+        return shorts.map { it.toFloat() / Short.MAX_VALUE }.toFloatArray()
+    }
+
+    private fun convert32BitPcmToFloat(bytes: ByteArray): FloatArray {
+        val ints = IntArray(bytes.size / 4)
+        ByteBuffer.wrap(bytes).order(ByteOrder.LITTLE_ENDIAN).asIntBuffer().get(ints)
+        return ints.map { it.toFloat() / Int.MAX_VALUE }.toFloatArray()
+    }
+
+    private fun convert8BitPcmToFloat(bytes: ByteArray): FloatArray {
+        return bytes.map { (it.toInt() - 128).toFloat() / 127f }.toFloatArray()
+    }
+
+    fun loadAudioRange(
+        fileUri: String,
+        startTimeMs: Long? = null,
+        endTimeMs: Long? = null,
+        config: DecodingConfig
+    ): AudioData? {
+        try {
+            // Clean up the URI and get a proper File object
+            val cleanUri = fileUri.removePrefix("file://")
+            val file = File(cleanUri).takeIf { it.exists() } ?: File(filesDir, File(cleanUri).name).takeIf { it.exists() }
+                ?: run {
+                    Log.e(Constants.TAG, "File not found in any location: $cleanUri")
+                    return null
+                }
+
+            // Check if it's a WAV file by reading first 4 bytes
+            val isWav = FileInputStream(file).use { fis ->
+                val header = ByteArray(4)
+                fis.read(header)
+                String(header) == "RIFF"
+            }
+
+            return if (isWav) {
+                loadWavRange(file, startTimeMs, endTimeMs, config)
+            } else {
+                loadCompressedAudioRange(file, startTimeMs, endTimeMs, config)
+            }
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Failed to load audio range: ${e.message}", e)
+            return null
+        }
+    }
+
+    private fun loadWavRange(
+        file: File,
+        startTimeMs: Long?,
+        endTimeMs: Long?,
+        config: DecodingConfig
+    ): AudioData? {
+        try {
+            // Read WAV header to get format info
+            val fis = FileInputStream(file)
+            val headerBuffer = ByteArray(44)  // WAV header is 44 bytes
+            fis.read(headerBuffer)
+            
+            // Parse WAV header
+            val sampleRate = ByteBuffer.wrap(headerBuffer, 24, 4).order(ByteOrder.LITTLE_ENDIAN).int
+            val channels = ByteBuffer.wrap(headerBuffer, 22, 2).order(ByteOrder.LITTLE_ENDIAN).short.toInt()
+            val bitDepth = ByteBuffer.wrap(headerBuffer, 34, 2).order(ByteOrder.LITTLE_ENDIAN).short.toInt()
+            
+            // Calculate duration
+            val bytesPerFrame = channels * (bitDepth / 8)
+            val numFrames = (file.length() - 44) / bytesPerFrame  // Subtract header size
+            val durationMs = (numFrames * 1000L) / sampleRate
+            
+            // Calculate positions
+            val startByte = 44 + ((startTimeMs ?: 0) * sampleRate * bytesPerFrame / 1000)
+            val endByte = 44 + ((endTimeMs ?: (file.length() * 1000 / (sampleRate * bytesPerFrame))) * sampleRate * bytesPerFrame / 1000)
+            val length = (endByte - startByte).toInt()
+            
+            Log.d(Constants.TAG, """
+                Loading WAV section:
+                - start: ${startTimeMs}ms (pos: $startByte)
+                - end: ${endTimeMs}ms (pos: $endByte)
+                - length: $length bytes
+                - format: ${sampleRate}Hz, $channels channels, $bitDepth-bit
+            """.trimIndent())
+            
+            // Read the requested section
+            val audioData = ByteArray(length)
+            fis.skip(startByte - 44)  // Skip to start position (accounting for header we already read)
+            fis.read(audioData)
+            fis.close()
+            
+            return AudioData(
+                data = audioData,
+                sampleRate = config.targetSampleRate ?: sampleRate,
+                channels = config.targetChannels ?: channels,
+                bitDepth = config.targetBitDepth ?: bitDepth,
+                durationMs = durationMs  // Pass the duration
+            )
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Failed to load WAV range: ${e.message}", e)
+            return null
+        }
+    }
+
+    private fun loadCompressedAudioRange(
+        file: File,
+        startTimeMs: Long?,
+        endTimeMs: Long?,
+        config: DecodingConfig
+    ): AudioData? {
+        val extractor = MediaExtractor()
+        var decoder: MediaCodec? = null
+        
+        try {
+            extractor.setDataSource(file.absolutePath)
+            val format = extractor.getTrackFormat(0)
+            extractor.selectTrack(0)
+
+            val originalSampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+            val originalChannels = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+            val totalDurationUs = try {
+                format.getLong(MediaFormat.KEY_DURATION)
+            } catch (e: Exception) {
+                (format.getString(MediaFormat.KEY_DURATION) ?: "-1").toLong()
+            }
+            Log.d("AudioProcessor", "Raw duration from format: ${totalDurationUs}us")
+            
+            val totalDurationMs = totalDurationUs / 1000
+            Log.d("AudioProcessor", "Final duration: ${totalDurationMs}ms")
+
+            // Calculate valid time range
+            val validStartMs = startTimeMs?.coerceIn(0, totalDurationMs) ?: 0
+            val validEndMs = endTimeMs?.coerceIn(validStartMs, totalDurationMs) ?: totalDurationMs
+            val effectiveDurationMs = validEndMs - validStartMs
+
+            // Initialize decoder
+            decoder = MediaCodec.createDecoderByType(format.getString(MediaFormat.KEY_MIME)!!)
+            decoder.configure(format, null, null, 0)
+            decoder.start()
+
+            // Seek to start position if needed
+            if (validStartMs > 0) {
+                extractor.seekTo(validStartMs * 1000, MediaExtractor.SEEK_TO_CLOSEST_SYNC)
+            }
+
+            // Calculate buffer sizes
+            val targetSampleRate = config.targetSampleRate ?: originalSampleRate
+            val targetChannels = config.targetChannels ?: originalChannels
+            val targetBitDepth = config.targetBitDepth ?: 16
+            val bytesPerSample = targetBitDepth / 8
+            val samplesPerSecond = targetSampleRate * targetChannels
+            val totalBytes = (effectiveDurationMs * samplesPerSecond * bytesPerSample) / 1000
+
+            Log.d(Constants.TAG, """
+                Loading audio range:
+                - start: ${validStartMs}ms
+                - end: ${validEndMs}ms
+                - duration: ${effectiveDurationMs}ms
+                - bytes: $totalBytes
+                - format: ${targetSampleRate}Hz, $targetChannels channels, $targetBitDepth-bit
+            """.trimIndent())
+
+            val outputBuffer = ByteBuffer.allocateDirect(totalBytes.toInt())
+            val bufferInfo = MediaCodec.BufferInfo()
+            var isEOS = false
+            
+            while (!isEOS) {
+                // Handle input
+                val inputBufferId = decoder.dequeueInputBuffer(10000)
+                if (inputBufferId >= 0) {
+                    val inputBuffer = decoder.getInputBuffer(inputBufferId)!!
+                    val sampleSize = extractor.readSampleData(inputBuffer, 0)
+                    
+                    when {
+                        sampleSize < 0 -> {
+                            decoder.queueInputBuffer(inputBufferId, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                            isEOS = true
+                        }
+                        extractor.sampleTime > validEndMs * 1000 -> {
+                            decoder.queueInputBuffer(inputBufferId, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                            isEOS = true
+                        }
+                        else -> {
+                            decoder.queueInputBuffer(inputBufferId, 0, sampleSize, extractor.sampleTime, 0)
+                            extractor.advance()
+                        }
+                    }
+                }
+
+                // Handle output
+                val outputBufferId = decoder.dequeueOutputBuffer(bufferInfo, 10000)
+                if (outputBufferId >= 0) {
+                    val outputBuffer = decoder.getOutputBuffer(outputBufferId)!!
+                    if (bufferInfo.size > 0) {
+                        outputBuffer.limit(bufferInfo.offset + bufferInfo.size)
+                        outputBuffer.position(bufferInfo.offset)
+                        if (outputBuffer.remaining() <= totalBytes - outputBuffer.position()) {
+                            outputBuffer.get(ByteArray(outputBuffer.remaining()))
+                        }
+                    }
+                    decoder.releaseOutputBuffer(outputBufferId, false)
+                }
+            }
+
+            outputBuffer.flip()
+            val audioData = ByteArray(outputBuffer.remaining())
+            outputBuffer.get(audioData)
+
+            return AudioData(
+                data = audioData,
+                sampleRate = targetSampleRate,
+                channels = targetChannels,
+                bitDepth = targetBitDepth,
+                durationMs = effectiveDurationMs  // Pass the duration
+            ).also {
+                Log.d(Constants.TAG, "Loaded compressed audio with duration: ${effectiveDurationMs}ms")
+            }
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Failed to load compressed audio range: ${e.message}", e)
+            return null
+        } finally {
+            decoder?.stop()
+            decoder?.release()
+            extractor.release()
+        }
+    }
+
+    // Future audio editing methods
+    fun trimAudio(
+        fileUri: String,
+        startTimeMs: Long,
+        endTimeMs: Long,
+        config: DecodingConfig? = null,
+        outputFileName: String? = null
+    ): AudioData? {
+        try {
+            // Load the specified range
+            val audioData = loadAudioRange(fileUri, startTimeMs, endTimeMs, config ?: DecodingConfig())
+                ?: return null
+            
+            // Generate output filename if not provided
+            val outputFile = if (outputFileName != null) {
+                File(filesDir, outputFileName)
+            } else {
+                val timestamp = System.currentTimeMillis()
+                File(filesDir, "trimmed_${timestamp}.wav")
+            }
+            
+            val durationMs = (endTimeMs - startTimeMs).toInt()
+            
+            Log.d(Constants.TAG, """
+                Trimming audio:
+                - start: ${startTimeMs}ms
+                - end: ${endTimeMs}ms
+                - duration: ${durationMs}ms
+                - output: ${outputFile.name}
+            """.trimIndent())
+
+            // Write WAV header
+            RandomAccessFile(outputFile, "rw").use { raf ->
+                // RIFF header
+                raf.write("RIFF".toByteArray())
+                val fileSize = audioData.data.size + 36 // File size minus RIFF header
+                raf.writeInt(fileSize)
+                raf.write("WAVE".toByteArray())
+
+                // fmt chunk
+                raf.write("fmt ".toByteArray())
+                raf.writeInt(16) // Subchunk1Size (16 for PCM)
+                val formatBytes = ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN)
+                formatBytes.putShort(1) // AudioFormat (1 for PCM)
+                raf.write(formatBytes.array())
+
+                val channelsBytes = ByteBuffer.allocate(2).order(ByteOrder.LITTLE_ENDIAN)
+                channelsBytes.putShort(audioData.channels.toShort())
+                raf.write(channelsBytes.array())
+
+                val sampleRateBytes = ByteBuffer.allocate(4).order(ByteOrder.LITTLE_ENDIAN)
+                sampleRateBytes.putInt(audioData.sampleRate)
+                raf.write(sampleRateBytes.array())
+                
+                val byteRate = audioData.sampleRate * audioData.channels * (audioData.bitDepth / 8)
+                raf.writeInt(byteRate) // ByteRate
+                
+                val blockAlign = audioData.channels * (audioData.bitDepth / 8)
+                raf.writeShort(blockAlign) // BlockAlign
+                raf.writeShort(audioData.bitDepth) // BitsPerSample
+
+                // data chunk
+                raf.write("data".toByteArray())
+                raf.writeInt(audioData.data.size) // Subchunk2Size
+                
+                // Write audio data
+                raf.write(audioData.data)
+            }
+
+            // Debug WAV header to verify
+            debugWavHeader(outputFile)
+
+            // Return the trimmed audio data
+            return AudioData(
+                data = audioData.data,
+                sampleRate = audioData.sampleRate,
+                channels = audioData.channels,
+                bitDepth = audioData.bitDepth
+            )
+        } catch (e: Exception) {
+            Log.e(Constants.TAG, "Failed to trim audio: ${e.message}", e)
+            return null
+        }
+    }
+
+    fun removeSection(
+        fileUri: String,
+        startTimeMs: Long,
+        endTimeMs: Long,
+        config: DecodingConfig? = null
+    ): AudioData? {
+        // TODO: Implement removing a section by concatenating before and after ranges
+        // This will use loadAudioRange to get two sections and join them
+        return null
+    }
+
+    fun joinAudioSections(
+        sections: List<AudioData>,
+        config: DecodingConfig? = null
+    ): AudioData? {
+        // TODO: Implement joining multiple audio sections
+        // This will be used by removeSection and other future editing features
+        return null
+    }
+
+    // Helper method for future editing features
+    private fun convertAudioFormat(
+        audioData: AudioData,
+        targetSampleRate: Int? = null,
+        targetChannels: Int? = null,
+        targetBitDepth: Int? = null
+    ): AudioData {
+        // TODO: Implement audio format conversion
+        // This will help ensure consistent format when joining sections
+        return audioData
+    }
 }