@siteed/audio-studio 3.1.0 → 3.1.1

package/android/src/main/java/net/siteed/audiostudio/AudioTrimmer.kt

@@ -15,7 +15,7 @@ import java.nio.ByteBuffer
 import kotlin.math.min
 
 class AudioTrimmer(
-    private val context: Context, 
+    private val context: Context,
     private val fileHandler: AudioFileHandler
 ) {
     companion object {
@@ -27,6 +27,10 @@ class AudioTrimmer(
         fun onProgress(progress: Float, bytesProcessed: Long, totalBytes: Long)
     }
 
+    private fun numberOption(options: Map<String, Any>, key: String): Int? {
+        return (options[key] as? Number)?.toInt()
+    }
+
     /**
      * Trims audio file based on the provided options
      */
@@ -48,19 +52,19 @@ class AudioTrimmer(
         try {
             // Resolve the input file URI
             val inputUri = Uri.parse(fileUri)
-            
+
             // Get audio file metadata
             val retriever = MediaMetadataRetriever()
             retriever.setDataSource(context, inputUri)
-            
+
             // Extract audio format information
             val audioFormat = getAudioFormat(retriever)
             Log.d(TAG, "Source audio format: $audioFormat")
-            
+
             // Validate and process output format options
             val formatOptions = outputFormat ?: emptyMap()
             val outputFormatType = (formatOptions["format"] as? String)?.lowercase() ?: "wav"
-            
+
             // Validate format and provide consistent fallback
             val effectiveFormatType = if (outputFormatType !in listOf("wav", "aac", "opus")) {
                 Log.w(TAG, "Unsupported format '$outputFormatType'. Falling back to 'aac'")
@@ -68,38 +72,38 @@ class AudioTrimmer(
             } else {
                 outputFormatType
             }
-            
+
             // Validate and normalize format-specific parameters
-            val sampleRate = (formatOptions["sampleRate"] as? Int)?.coerceIn(8000, 48000) 
+            val sampleRate = numberOption(formatOptions, "sampleRate")?.coerceIn(8000, 48000)
                 ?: audioFormat.sampleRate
-            val channels = (formatOptions["channels"] as? Int)?.coerceIn(1, 2) 
+            val channels = numberOption(formatOptions, "channels")?.coerceIn(1, 2)
                 ?: audioFormat.channels
-            val bitDepth = (formatOptions["bitDepth"] as? Int)?.coerceIn(8, 32) 
+            val bitDepth = numberOption(formatOptions, "bitDepth")?.coerceIn(8, 32)
                 ?: audioFormat.bitDepth
-            val bitrate = (formatOptions["bitrate"] as? Int)?.coerceIn(8000, 320000) 
+            val bitrate = numberOption(formatOptions, "bitrate")?.coerceIn(8000, 320000)
                 ?: 128000
-            
+
             Log.d(TAG, "Output format parameters: format=$effectiveFormatType, sampleRate=$sampleRate, " +
                   "channels=$channels, bitDepth=$bitDepth, bitrate=$bitrate")
-            
+
             // Determine the appropriate extension and format
             val extension = when (effectiveFormatType) {
                 "wav" -> "wav"
                 "opus" -> "opus"
                 else -> "m4a" // Use m4a extension for AAC to match iOS
             }
-            
+
             Log.d(TAG, "Using output extension: $extension")
-            
+
             // Create output file
             val outputFile = if (outputFileName != null) {
                 File(context.filesDir, "$outputFileName.$extension")
             } else {
                 fileHandler.createAudioFile(extension)
             }
-            
+
             Log.d(TAG, "Created output file: ${outputFile.absolutePath}")
-            
+
             // Determine the time ranges to process based on the mode
             val timeRanges = when (mode) {
                 "single" -> {
@@ -112,34 +116,34 @@ class AudioTrimmer(
                     // For remove mode, we need to invert the ranges
                     val invertedRanges = mutableListOf<Map<String, Long>>()
                     var lastEndTime = 0L
-                    
+
                     ranges?.sortedBy { it["startTimeMs"] }?.forEach { range ->
                         val start = range["startTimeMs"] ?: 0L
                         val end = range["endTimeMs"] ?: audioFormat.durationMs
-                        
+
                         if (start > lastEndTime) {
                             invertedRanges.add(mapOf("startTimeMs" to lastEndTime, "endTimeMs" to start))
                         }
                         lastEndTime = end
                     }
-                    
+
                     if (lastEndTime < audioFormat.durationMs) {
                         invertedRanges.add(mapOf("startTimeMs" to lastEndTime, "endTimeMs" to audioFormat.durationMs))
                     }
-                    
+
                     invertedRanges
                 }
                 else -> throw IllegalArgumentException("Invalid mode: $mode")
             }
-            
+
             // Check if we need format conversion
-            val needFormatChange = formatOptions["sampleRate"] != null || 
-                                  formatOptions["channels"] != null || 
+            val needFormatChange = formatOptions["sampleRate"] != null ||
+                                  formatOptions["channels"] != null ||
                                   formatOptions["bitDepth"] != null
-            
+
             // Check if input is WAV format
             val isWavInput = audioFormat.mimeType == "audio/wav" || audioFormat.mimeType == "audio/x-wav"
-            
+
             // Optimized approach based on input/output formats
             if (isWavInput && extension == "wav" && !needFormatChange) {
                 // Fast path for WAV-to-WAV with no format changes
@@ -152,12 +156,12 @@ class AudioTrimmer(
                 // Need to decode and possibly re-encode
                 Log.d(TAG, "Using decode/encode path for non-WAV input or format conversion")
                 val config = DecodingConfig(
-                    targetSampleRate = formatOptions["sampleRate"] as? Int,
-                    targetChannels = formatOptions["channels"] as? Int,
-                    targetBitDepth = formatOptions["bitDepth"] as? Int ?: 16,
+                    targetSampleRate = sampleRate,
+                    targetChannels = channels,
+                    targetBitDepth = bitDepth,
                     normalizeAudio = false
                 )
-                
+
                 if (extension == "wav") {
                     // For any format to WAV conversion
                     Log.d(TAG, "Processing to WAV with possible format conversion")
@@ -172,7 +176,7 @@ class AudioTrimmer(
                     // For compressed output formats (AAC, Opus)
                     Log.d(TAG, "Processing to compressed format: $extension")
                     val tempWavFile = File(context.filesDir, "temp_${System.currentTimeMillis()}.wav")
-                    
+
                     try {
                         // First decode to WAV
                         processToWav(
@@ -186,20 +190,20 @@ class AudioTrimmer(
                                 }
                             }
                         )
-                        
+
                         // Now encode to the target format
                         if (extension == "opus") {
                             val audioProcessor = AudioProcessor(context.filesDir)
                             val audioData = audioProcessor.loadAudioFromAnyFormat(
                                 tempWavFile.absolutePath,
                                 DecodingConfig(
-                                    targetSampleRate = formatOptions["sampleRate"] as? Int ?: 16000,
-                                    targetChannels = formatOptions["channels"] as? Int ?: 1,
+                                    targetSampleRate = sampleRate,
+                                    targetChannels = channels,
                                     targetBitDepth = 16,
                                     normalizeAudio = false
                                 )
                             ) ?: throw IOException("Failed to load WAV file")
-                            
+
                             encodeToOpus(
                                 audioData,
                                 outputFile,
@@ -231,23 +235,23 @@ class AudioTrimmer(
                     }
                 }
             }
-            
+
             // Get output file metadata
             val outputFileSize = outputFile.length()
             val outputDurationMs = calculateOutputDuration(timeRanges)
-            
+
             // Extract audio format details
             val extractor = MediaExtractor()
             try {
                 extractor.setDataSource(outputFile.absolutePath)
-                
+
                 // Initialize variables that will be populated from the file or user options
                 val outputBitrate: Int
 
                 // First try to get values from the output file
                 if (extractor.trackCount > 0) {
                     val format = extractor.getTrackFormat(0)
-                    
+
                     outputBitrate = if (format.containsKey(MediaFormat.KEY_BIT_RATE)) {
                         format.getInteger(MediaFormat.KEY_BIT_RATE)
                     } else {
@@ -258,14 +262,14 @@ class AudioTrimmer(
                     // If we can't get from the file, use user options or defaults
                     outputBitrate = bitrate
                 }
-                
+
                 // Determine the correct MIME type
                 val mimeType = when (extension) {
                     "m4a" -> "audio/mp4"  // Use audio/mp4 for AAC to match iOS
                     "opus" -> "audio/ogg" // Use audio/ogg for Opus
                     else -> "audio/wav"
                 }
-                
+
                 val result = mutableMapOf<String, Any>(
                     "uri" to outputFile.absolutePath,
                     "filename" to outputFile.name,
@@ -278,7 +282,7 @@ class AudioTrimmer(
                     "requestedFormat" to (formatOptions["format"] as? String ?: "wav"), // Add the originally requested format
                     "actualFormat" to extension     // Add the actual format used
                 )
-                
+
                 // Add compression info if not WAV
                 if (extension != "wav") {
                     result["compression"] = mapOf(
@@ -287,20 +291,20 @@ class AudioTrimmer(
                         "size" to outputFileSize
                     )
                 }
-                
+
                 Log.d(TAG, "Audio trim completed in ${System.currentTimeMillis() - startTime}ms")
                 return result
             } catch (e: Exception) {
                 Log.e(TAG, "Error reading output file metadata: ${e.message}")
                 // Continue with basic metadata if extractor fails
-                
+
                 // Determine the correct MIME type
                 val mimeType = when (extension) {
                     "m4a" -> "audio/mp4"  // Use audio/mp4 for AAC to match iOS
                     "opus" -> "audio/ogg" // Use audio/ogg for Opus
                     else -> "audio/wav"
                 }
-                
+
                 val result = mutableMapOf<String, Any>(
                     "uri" to outputFile.absolutePath,
                     "filename" to outputFile.name,
@@ -313,7 +317,7 @@ class AudioTrimmer(
                     "requestedFormat" to (formatOptions["format"] as? String ?: "wav"),
                     "actualFormat" to extension
                 )
-                
+
                 // Add compression info if not WAV
                 if (extension != "wav") {
                     result["compression"] = mapOf(
@@ -322,7 +326,7 @@ class AudioTrimmer(
                         "size" to outputFileSize
                     )
                 }
-                
+
                 Log.d(TAG, "Audio trim completed in ${System.currentTimeMillis() - startTime}ms")
                 return result
             } finally {
@@ -332,7 +336,7 @@ class AudioTrimmer(
                     // Ignore
                 }
             }
-            
+
         } catch (e: Exception) {
             Log.e(TAG, "Error trimming audio", e)
             throw e
@@ -348,7 +352,7 @@ class AudioTrimmer(
         }
         return totalDurationMs
     }
-    
+
     /**
      * Optimized version of processWavFile that directly copies bytes from input to output
      * without decoding the entire file
@@ -362,111 +366,111 @@ class AudioTrimmer(
         // Get input file path from URI
         val inputPath = inputUri.path ?: throw IOException("Invalid input URI")
         val inputFile = File(inputPath)
-        
+
         if (!inputFile.exists()) {
             throw IOException("Input file does not exist: $inputPath")
         }
-        
+
         // Create output file if it doesn't exist
         if (!outputFile.exists() && !outputFile.createNewFile()) {
             throw IOException("Failed to create output file: ${outputFile.path}")
         }
-        
+
         // Use AudioProcessor to determine actual WAV header length
         val audioProcessor = AudioProcessor(context.filesDir)
         val headerSize = audioProcessor.getWavHeaderSize(inputFile.absolutePath) ?: 44 // Default to 44 if we can't determine
-        
+
         // Read WAV header to get format information using 'use' pattern
         val headerBuffer = FileInputStream(inputFile).use { inputStream ->
             ByteArray(headerSize).also { buffer ->
                 inputStream.read(buffer)
             }
         }
-        
+
         // Parse header to get format info
         val sampleRate = ByteBuffer.wrap(headerBuffer, 24, 4).order(java.nio.ByteOrder.LITTLE_ENDIAN).int
         val channels = ByteBuffer.wrap(headerBuffer, 22, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).short.toInt()
         val bitDepth = ByteBuffer.wrap(headerBuffer, 34, 2).order(java.nio.ByteOrder.LITTLE_ENDIAN).short.toInt()
-        
+
         // Get file duration using MediaMetadataRetriever for consistency
         val retriever = MediaMetadataRetriever()
         retriever.setDataSource(inputFile.absolutePath)
         val durationMsStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)
         val fileDurationMs = durationMsStr?.toLong() ?: 0
         retriever.release()
-        
+
         // Create output file with WAV header
         FileOutputStream(outputFile).use { outputStream ->
             fileHandler.writeWavHeader(outputStream, sampleRate, channels, bitDepth)
-            
+
             // Process each time range
             val bytesPerSample = bitDepth / 8
             val bytesPerFrame = bytesPerSample * channels
             val buffer = ByteArray(BUFFER_SIZE - (BUFFER_SIZE % bytesPerFrame)) // Ensure buffer size is multiple of frame size
-            
+
             var totalBytesProcessed = 0L
             val totalRangeDuration = calculateOutputDuration(timeRanges)
             var currentRangeProcessed = 0L
-            
+
             var lastUpdateTime = 0L
             val updateIntervalMs = 100L // Update progress every 100ms
-            
+
             for (range in timeRanges) {
                 val startTimeMs = range["startTimeMs"] ?: 0
                 val endTimeMs = range["endTimeMs"] ?: fileDurationMs // Use actual file duration instead of Long.MAX_VALUE
-                
+
                 // Calculate byte positions
                 val startByte = headerSize + ((startTimeMs * sampleRate * bytesPerFrame) / 1000)
                 val endByte = headerSize + ((endTimeMs * sampleRate * bytesPerFrame) / 1000)
-                
+
                 val rangeSize = endByte - startByte
                 val rangeDuration = endTimeMs - startTimeMs
-                
+
                 // Read and write the range using 'use' pattern
                 FileInputStream(inputFile).use { rangeInputStream ->
                     if (rangeInputStream.skip(startByte) != startByte) {
                         throw IOException("Failed to skip to position $startByte in input file")
                     }
-                    
+
                     var bytesRead: Int
                     var rangeProcessed = 0L
-                    
+
                     while (rangeInputStream.read(buffer).also { bytesRead = it } > 0 && rangeProcessed < rangeSize) {
                         // Ensure we don't read past the range
                         val bytesToWrite = min(bytesRead.toLong(), rangeSize - rangeProcessed).toInt()
-                        
+
                         outputStream.write(buffer, 0, bytesToWrite)
-                        
+
                         rangeProcessed += bytesToWrite
                         totalBytesProcessed += bytesToWrite
-                        
+
                         // Calculate progress based on time for consistency with compressed audio
                         val currentTimeInRange = (rangeProcessed * 1000) / (sampleRate * bytesPerFrame)
-                        
+
                         // Calculate overall progress directly
                         val overallProgress = (currentRangeProcessed + currentTimeInRange).toFloat() / totalRangeDuration
-                        
+
                         val currentTime = System.currentTimeMillis()
                         if (currentTime - lastUpdateTime >= updateIntervalMs) {
                             progressCallback(overallProgress * 100, bytesToWrite.toLong(), totalRangeDuration)
                             lastUpdateTime = currentTime
                         }
-                        
+
                         // Break if we've read the entire range
                         if (rangeProcessed >= rangeSize) {
                             break
                         }
                     }
                 }
-                
+
                 currentRangeProcessed += rangeDuration
             }
         }
-        
+
         // Update WAV header with correct file size
         fileHandler.updateWavHeader(outputFile)
     }
-    
+
     /**
      * Optimized version of processToWav that processes audio ranges more efficiently
      */
@@ -478,74 +482,32 @@ class AudioTrimmer(
         progressListener: ProgressListener?
     ) {
         val audioProcessor = AudioProcessor(context.filesDir)
-        val isWavInput = try {
-            val mimeType = MediaMetadataRetriever().apply { 
-                setDataSource(context, inputUri) 
-            }.extractMetadata(MediaMetadataRetriever.METADATA_KEY_MIMETYPE)
-            mimeType == "audio/wav" || mimeType == "audio/x-wav"
-        } catch (e: Exception) {
-            false
-        }
-        
+
         // Create output file with WAV header
         FileOutputStream(outputFile).use { outputStream ->
             // We'll write the header at the end when we know the total size
             var totalBytes = 0L
             var totalProgress: Float
             val totalRanges = timeRanges.size
-            
+
             // Process each time range
             for ((index, range) in timeRanges.withIndex()) {
                 val startTimeMs = range["startTimeMs"] ?: 0
                 val endTimeMs = range["endTimeMs"] ?: 0
                 val rangeDuration = endTimeMs - startTimeMs
-                
+
                 Log.d(TAG, "Processing range $index: $startTimeMs-$endTimeMs ms")
-                
-                // Load just this range of audio - use the optimized method for compressed audio
-                val audioData = if (isWavInput) {
-                    // For WAV files, use the existing method
-                    audioProcessor.loadAudioRange(
-                        fileUri = inputUri.toString(),
-                        startTimeMs = startTimeMs,
-                        endTimeMs = endTimeMs,
-                        config = config
-                    )
-                } else {
-                    // For compressed audio, use the new optimized method
-                    audioProcessor.decodeAudioRangeToPCM(
-                        fileUri = inputUri.toString(),
-                        startTimeMs = startTimeMs,
-                        endTimeMs = endTimeMs
-                    )?.let { decodedData ->
-                        // Apply any format conversion if needed
-                        if (config.targetSampleRate != null && config.targetSampleRate != decodedData.sampleRate ||
-                            config.targetChannels != null && config.targetChannels != decodedData.channels) {
-                            
-                            // Need to resample or convert channels
-                            val resampledData = audioProcessor.processAudio(
-                                decodedData.data,
-                                decodedData.sampleRate,
-                                decodedData.channels,
-                                config.targetSampleRate ?: decodedData.sampleRate,
-                                config.targetChannels ?: decodedData.channels,
-                                config.normalizeAudio
-                            )
-                            
-                            AudioProcessor.AudioData(
-                                data = resampledData,
-                                sampleRate = config.targetSampleRate ?: decodedData.sampleRate,
-                                channels = config.targetChannels ?: decodedData.channels,
-                                bitDepth = decodedData.bitDepth,
-                                durationMs = decodedData.durationMs
-                            )
-                        } else {
-                            // No conversion needed
-                            decodedData
-                        }
-                    }
-                } ?: throw IOException("Failed to load audio range $startTimeMs-$endTimeMs")
-                
+
+                // Load just this range through AudioProcessor's canonical range path. It handles
+                // WAV and compressed inputs, target sample rate/channel/bit depth conversion, and
+                // final-byte metadata consistently for trimAudio and extractAudioData.
+                val audioData = audioProcessor.loadAudioRange(
+                    fileUri = inputUri.toString(),
+                    startTimeMs = startTimeMs,
+                    endTimeMs = endTimeMs,
+                    config = config
+                ) ?: throw IOException("Failed to load audio range $startTimeMs-$endTimeMs")
+
                 // For the first range, write the WAV header
                 if (index == 0) {
                     fileHandler.writeWavHeader(
@@ -555,23 +517,23 @@ class AudioTrimmer(
                         audioData.bitDepth
                     )
                 }
-                
+
                 // Write the PCM data for this range
                 outputStream.write(audioData.data)
                 totalBytes += audioData.data.size
-                
+
                 // Update progress
                 val rangeProgress = (index + 1).toFloat() / totalRanges
                 totalProgress = rangeProgress * 100
                 progressListener?.onProgress(totalProgress, audioData.data.size.toLong(), rangeDuration)
-                
+
                 Log.d(TAG, "Range $index processed: ${audioData.data.size} bytes, ${audioData.durationMs} ms")
             }
         }
-        
+
         // Update WAV header with correct file size
         fileHandler.updateWavHeader(outputFile)
-        
+
         Log.d(TAG, "WAV file created successfully: ${outputFile.absolutePath}")
     }
 
@@ -586,18 +548,18 @@ class AudioTrimmer(
     ) {
         // Increase MediaCodec buffer size
         val largerInputBufferSize = 65536 // 64KB
-        
+
         Log.d(TAG, "Encoding WAV to AAC: ${inputWavFile.absolutePath} -> ${outputAacFile.absolutePath}")
-        
+
         // Get WAV file details
         val audioProcessor = AudioProcessor(context.filesDir)
         val audioFormat = audioProcessor.getAudioFormat(inputWavFile.absolutePath)
             ?: throw IOException("Failed to get audio format from WAV file")
-        
-        val sampleRate = formatOptions["sampleRate"] as? Int ?: audioFormat.sampleRate
-        val channels = formatOptions["channels"] as? Int ?: audioFormat.channels
-        val bitrate = formatOptions["bitrate"] as? Int ?: 128000
-        
+
+        val sampleRate = numberOption(formatOptions, "sampleRate") ?: audioFormat.sampleRate
+        val channels = numberOption(formatOptions, "channels") ?: audioFormat.channels
+        val bitrate = numberOption(formatOptions, "bitrate") ?: 128000
+
         // Load the entire WAV file as PCM data
         val audioData = audioProcessor.loadAudioFromAnyFormat(
             inputWavFile.absolutePath,
@@ -608,22 +570,22 @@ class AudioTrimmer(
                 normalizeAudio = false
             )
         ) ?: throw IOException("Failed to load WAV file")
-        
+
         // Set up MediaCodec for AAC encoding
         val mediaFormat = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_AAC, sampleRate, channels)
         mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
         mediaFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, android.media.MediaCodecInfo.CodecProfileLevel.AACObjectLC)
         mediaFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, largerInputBufferSize)
-        
+
         val encoder = android.media.MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC)
         encoder.configure(mediaFormat, null, null, android.media.MediaCodec.CONFIGURE_FLAG_ENCODE)
         encoder.start()
-        
+
         // Set up MediaMuxer for MP4 container
         val muxer = MediaMuxer(outputAacFile.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
         var trackIndex = -1
         var muxerStarted = false
-        
+
         try {
             val bufferInfo = android.media.MediaCodec.BufferInfo()
             val timeoutUs = 10000L
@@ -632,18 +594,18 @@ class AudioTrimmer(
             val totalBytes = audioData.data.size.toLong()
             var allInputSubmitted = false
             var encoderDone = false
-            
+
             // Calculate bytes per frame
             val bytesPerSample = audioData.bitDepth / 8
             val bytesPerFrame = bytesPerSample * audioData.channels
             val frameSizeInBytes = 65536 // 64KB buffer instead of smaller chunks
-            
+
             // Process the PCM data in larger chunks
             var inputOffset = 0
-            
+
             var lastUpdateTime = 0L
             val updateIntervalMs = 100L
-            
+
             while (!encoderDone) {
                 // Submit input data if we have any left
                 if (!allInputSubmitted) {
@@ -651,21 +613,21 @@ class AudioTrimmer(
                     if (inputBufferIndex >= 0) {
                         val inputBuffer = encoder.getInputBuffer(inputBufferIndex)
                         inputBuffer?.clear()
-                        
+
                         // Calculate how many bytes to read
                         val bytesToRead = if (inputOffset + frameSizeInBytes <= audioData.data.size) {
                             frameSizeInBytes
                         } else {
                             audioData.data.size - inputOffset
                         }
-                        
+
                         if (bytesToRead > 0) {
                             // Copy data to the input buffer
                             inputBuffer?.put(audioData.data, inputOffset, bytesToRead)
-                            
+
                             // Calculate presentation time in microseconds
                             val frameDurationUs = (bytesToRead * 1000000L) / (sampleRate * bytesPerFrame)
-                            
+
                             // Submit the input buffer
                             encoder.queueInputBuffer(
                                 inputBufferIndex,
@@ -674,12 +636,12 @@ class AudioTrimmer(
                                 presentationTimeUs,
                                 0
                             )
-                            
+
                             // Update state
                             presentationTimeUs += frameDurationUs
                             inputOffset += bytesToRead
                             totalBytesProcessed += bytesToRead
-                            
+
                             // Report progress
                             val progress = (totalBytesProcessed * 100f) / totalBytes
                             val currentTime = System.currentTimeMillis()
@@ -700,7 +662,7 @@ class AudioTrimmer(
                         }
                     }
                 }
-                
+
                 // Get encoded output
                 val outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, timeoutUs)
                 if (outputBufferIndex == android.media.MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
@@ -716,25 +678,25 @@ class AudioTrimmer(
                 } else if (outputBufferIndex >= 0) {
                     // Got encoded data
                     val encodedData = encoder.getOutputBuffer(outputBufferIndex)
-                    
+
                     if (encodedData != null) {
                         if ((bufferInfo.flags and android.media.MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                             // Codec config data, not actual media data
                             bufferInfo.size = 0
                         }
-                        
+
                         if (bufferInfo.size > 0 && muxerStarted) {
                             // Adjust buffer info offset and size for the buffer
                             encodedData.position(bufferInfo.offset)
                             encodedData.limit(bufferInfo.offset + bufferInfo.size)
-                            
+
                             // Write to muxer
                             muxer.writeSampleData(trackIndex, encodedData, bufferInfo)
                         }
-                        
+
                         // Release the output buffer
                         encoder.releaseOutputBuffer(outputBufferIndex, false)
-                        
+
                         // Check if we're done
                         if ((bufferInfo.flags and android.media.MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                             encoderDone = true
@@ -742,10 +704,10 @@ class AudioTrimmer(
                     }
                 }
             }
-            
+
             // Make sure we report 100% progress
             progressListener?.onProgress(100f, totalBytes, totalBytes)
-            
+
         } finally {
             // Clean up resources
             try {
@@ -754,7 +716,7 @@ class AudioTrimmer(
             } catch (e: Exception) {
                 Log.w(TAG, "Error releasing encoder: ${e.message}")
             }
-            
+
             if (muxerStarted) {
                 try {
                     muxer.stop()
@@ -762,14 +724,14 @@ class AudioTrimmer(
                     Log.w(TAG, "Error stopping muxer: ${e.message}")
                 }
             }
-            
+
             try {
                 muxer.release()
             } catch (e: Exception) {
                 Log.w(TAG, "Error releasing muxer: ${e.message}")
             }
         }
-        
+
         Log.d(TAG, "WAV to AAC encoding completed successfully")
     }
 
@@ -783,7 +745,7 @@ class AudioTrimmer(
         progressListener: ProgressListener?
     ) {
         Log.d(TAG, "Encoding to Opus: ${outputFile.absolutePath}")
-        
+
         try {
             // Check if Opus codec is available
             val codecList = android.media.MediaCodecList(android.media.MediaCodecList.REGULAR_CODECS)
@@ -791,10 +753,10 @@ class AudioTrimmer(
                 .filter { it.isEncoder && it.supportedTypes.contains(MediaFormat.MIMETYPE_AUDIO_OPUS) }
                 .map { it.name }
                 .firstOrNull()
-            
+
             if (opusCodecName == null) {
                 Log.w(TAG, "Opus encoder not available, falling back to AAC")
-                
+
                 // Create a temporary WAV file
                 val tempWavFile = File(context.filesDir, "temp_${System.currentTimeMillis()}.wav")
                 try {
@@ -808,14 +770,14 @@ class AudioTrimmer(
                             audioData.channels,
                             audioData.bitDepth
                         )
-                        
+
                         // Write PCM data
                         outputStream.write(audioData.data)
                     }
-                    
+
                     // Update WAV header with correct file size
                     audioFileHandler.updateWavHeader(tempWavFile)
-                    
+
                     // Now we can call encodeWavToAac with the temp file
                     encodeWavToAac(
                         tempWavFile,
@@ -831,23 +793,23 @@ class AudioTrimmer(
                 }
                 return
             }
-            
+
             // Set up MediaCodec for Opus encoding
-            val sampleRate = formatOptions["sampleRate"] as? Int ?: audioData.sampleRate
-            val channels = formatOptions["channels"] as? Int ?: audioData.channels
-            
+            val sampleRate = numberOption(formatOptions, "sampleRate") ?: audioData.sampleRate
+            val channels = numberOption(formatOptions, "channels") ?: audioData.channels
+
             // Determine appropriate bitrate based on content type and channels
             // For voice: 8-24kbps for mono, 16-32kbps for stereo is typically sufficient
             val defaultBitrate = if (channels > 1) 32000 else 16000 // Lower defaults for voice
-            val bitrate = formatOptions["bitrate"] as? Int ?: defaultBitrate
-            
+            val bitrate = numberOption(formatOptions, "bitrate") ?: defaultBitrate
+
             // Determine if this is voice content based on sample rate and/or explicit flag
             val isVoiceContent = formatOptions["isVoice"] as? Boolean ?: (sampleRate <= 16000)
-            
+
             val mediaFormat = MediaFormat.createAudioFormat(MediaFormat.MIMETYPE_AUDIO_OPUS, sampleRate, channels)
             mediaFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitrate)
             mediaFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 65536)
-            
+
             // Set complexity - lower for voice (faster encoding, still good quality)
             // Complexity range is 0-10, with 10 being highest quality but slowest
             val complexity = if (isVoiceContent) 5 else 7
@@ -876,12 +838,12 @@ class AudioTrimmer(
             val encoder = android.media.MediaCodec.createByCodecName(opusCodecName)
             encoder.configure(mediaFormat, null, null, android.media.MediaCodec.CONFIGURE_FLAG_ENCODE)
             encoder.start()
-            
+
             // Set up MediaMuxer for Opus container (using OGG container)
             val muxer = MediaMuxer(outputFile.absolutePath, MediaMuxer.OutputFormat.MUXER_OUTPUT_OGG)
             var trackIndex = -1
             var muxerStarted = false
-            
+
             try {
                 val bufferInfo = android.media.MediaCodec.BufferInfo()
                 val timeoutUs = 10000L
@@ -890,18 +852,18 @@ class AudioTrimmer(
                 val totalBytes = audioData.data.size.toLong()
                 var allInputSubmitted = false
                 var encoderDone = false
-                
+
                 // Calculate bytes per frame
                 val bytesPerSample = audioData.bitDepth / 8
                 val bytesPerFrame = bytesPerSample * audioData.channels
                 val frameSizeInBytes = 65536 // 64KB buffer instead of smaller chunks
-                
+
                 // Process the PCM data in chunks
                 var inputOffset = 0
-                
+
                 var lastUpdateTime = 0L
                 val updateIntervalMs = 100L
-                
+
                 while (!encoderDone) {
                     // Submit input data if we have any left
                     if (!allInputSubmitted) {
@@ -909,21 +871,21 @@ class AudioTrimmer(
                         if (inputBufferIndex >= 0) {
                             val inputBuffer = encoder.getInputBuffer(inputBufferIndex)
                             inputBuffer?.clear()
-                            
+
                             // Calculate how many bytes to read
                             val bytesToRead = if (inputOffset + frameSizeInBytes <= audioData.data.size) {
                                 frameSizeInBytes
                             } else {
                                 audioData.data.size - inputOffset
                             }
-                            
+
                             if (bytesToRead > 0) {
                                 // Copy data to the input buffer
                                 inputBuffer?.put(audioData.data, inputOffset, bytesToRead)
-                                
+
                                 // Calculate presentation time in microseconds
                                 val frameDurationUs = (bytesToRead * 1000000L) / (sampleRate * bytesPerFrame)
-                                
+
                                 // Submit the input buffer
                                 encoder.queueInputBuffer(
                                     inputBufferIndex,
@@ -932,12 +894,12 @@ class AudioTrimmer(
                                     presentationTimeUs,
                                     0
                                 )
-                                
+
                                 // Update state
                                 presentationTimeUs += frameDurationUs
                                 inputOffset += bytesToRead
                                 totalBytesProcessed += bytesToRead
-                                
+
                                 // Report progress
                                 val progress = (totalBytesProcessed * 100f) / totalBytes
                                 val currentTime = System.currentTimeMillis()
@@ -958,7 +920,7 @@ class AudioTrimmer(
                             }
                         }
                     }
-                    
+
                     // Get encoded output
                     val outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, timeoutUs)
                     if (outputBufferIndex == android.media.MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
@@ -974,25 +936,25 @@ class AudioTrimmer(
                     } else if (outputBufferIndex >= 0) {
                         // Got encoded data
                         val encodedData = encoder.getOutputBuffer(outputBufferIndex)
-                        
+
                         if (encodedData != null) {
                             if ((bufferInfo.flags and android.media.MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
                                 // Codec config data, not actual media data
                                 bufferInfo.size = 0
                             }
-                            
+
                             if (bufferInfo.size > 0 && muxerStarted) {
                                 // Adjust buffer info offset and size for the buffer
                                 encodedData.position(bufferInfo.offset)
                                 encodedData.limit(bufferInfo.offset + bufferInfo.size)
-                                
+
                                 // Write to muxer
                                 muxer.writeSampleData(trackIndex, encodedData, bufferInfo)
                             }
-                            
+
                             // Release the output buffer
                             encoder.releaseOutputBuffer(outputBufferIndex, false)
-                            
+
                             // Check if we're done
                             if ((bufferInfo.flags and android.media.MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
                                 encoderDone = true
@@ -1000,10 +962,10 @@ class AudioTrimmer(
                         }
                     }
                 }
-                
+
                 // Make sure we report 100% progress
                 progressListener?.onProgress(100f, totalBytes, totalBytes)
-                
+
             } finally {
                 // Clean up resources
                 try {
@@ -1012,7 +974,7 @@ class AudioTrimmer(
                 } catch (e: Exception) {
                     Log.w(TAG, "Error releasing encoder: ${e.message}")
                 }
-                
+
                 if (muxerStarted) {
                     try {
                         muxer.stop()
@@ -1020,21 +982,21 @@ class AudioTrimmer(
                         Log.w(TAG, "Error stopping muxer: ${e.message}")
                     }
                 }
-                
+
                 try {
                     muxer.release()
                 } catch (e: Exception) {
                     Log.w(TAG, "Error releasing muxer: ${e.message}")
                 }
             }
-            
+
             Log.d(TAG, "Opus encoding completed successfully")
         } catch (e: Exception) {
             Log.e(TAG, "Error encoding to Opus: ${e.message}", e)
-            
+
             // Fall back to AAC if Opus encoding fails
             Log.w(TAG, "Opus encoding failed, falling back to AAC")
-            
+
             // Create a temporary WAV file
             val tempWavFile = File(context.filesDir, "temp_${System.currentTimeMillis()}.wav")
             try {
@@ -1050,7 +1012,7 @@ class AudioTrimmer(
                     outputStream.write(audioData.data)
                 }
                 audioFileHandler.updateWavHeader(tempWavFile)
-                
+
                 // Encode to AAC
                 encodeWavToAac(
                     tempWavFile,
@@ -1063,7 +1025,7 @@ class AudioTrimmer(
                     tempWavFile.delete()
                 }
             }
-            
+
             throw IOException("Failed to encode to Opus: ${e.message}", e)
         }
     }
@@ -1075,16 +1037,16 @@ class AudioTrimmer(
             // Estimate channels from bitrate and sample rate if not directly available
             if (it > sampleRate * 16) 2 else 1
         } ?: 1
-        
+
         // Bit depth is often not directly available, assume 16-bit as default
         val bitDepth = 16
-        
+
         // Get duration in milliseconds
         val durationMs = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)?.toLongOrNull() ?: 0L
-        
+
         // Get MIME type
         val mimeType = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_MIMETYPE) ?: "audio/mpeg"
-        
+
         return AudioFormat(sampleRate, channels, bitDepth, durationMs, mimeType)
     }
 
@@ -1096,4 +1058,4 @@ class AudioTrimmer(
         val durationMs: Long = 0,
         val mimeType: String = "audio/mpeg"
     )
-} 
+}