react-native-audio-concat 0.5.0 → 0.6.0

package/android/src/main/java/com/audioconcat/AudioConcatModule.kt

@@ -160,6 +160,87 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  // Helper class to manage MediaCodec decoder reuse
+  private class ReusableDecoder {
+    private var decoder: MediaCodec? = null
+    private var currentMimeType: String? = null
+    private var currentFormat: MediaFormat? = null
+
+    fun getOrCreateDecoder(mimeType: String, format: MediaFormat): MediaCodec {
+      // Check if we can reuse the existing decoder
+      if (decoder != null && currentMimeType == mimeType && formatsCompatible(currentFormat, format)) {
+        // Flush the decoder to reset its state
+        try {
+          decoder!!.flush()
+          Log.d("AudioConcat", "  Reused decoder for $mimeType")
+          return decoder!!
+        } catch (e: Exception) {
+          Log.w("AudioConcat", "Failed to flush decoder, recreating: ${e.message}")
+          release()
+        }
+      }
+
+      // Need to create a new decoder
+      release() // Release old one if exists
+
+      val newDecoder = MediaCodec.createDecoderByType(mimeType)
+      newDecoder.configure(format, null, null, 0)
+      newDecoder.start()
+
+      decoder = newDecoder
+      currentMimeType = mimeType
+      currentFormat = format
+
+      Log.d("AudioConcat", "  Created new decoder for $mimeType")
+      return newDecoder
+    }
+
+    private fun formatsCompatible(format1: MediaFormat?, format2: MediaFormat): Boolean {
+      if (format1 == null) return false
+
+      // Check key format properties
+      return try {
+        format1.getInteger(MediaFormat.KEY_SAMPLE_RATE) == format2.getInteger(MediaFormat.KEY_SAMPLE_RATE) &&
+        format1.getInteger(MediaFormat.KEY_CHANNEL_COUNT) == format2.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+      } catch (e: Exception) {
+        false
+      }
+    }
+
+    fun release() {
+      decoder?.let {
+        try {
+          it.stop()
+          it.release()
+        } catch (e: Exception) {
+          Log.w("AudioConcat", "Error releasing decoder: ${e.message}")
+        }
+      }
+      decoder = null
+      currentMimeType = null
+      currentFormat = null
+    }
+  }
+
+  // Thread-safe decoder pool for parallel processing
+  private class DecoderPool {
+    private val decoders = ConcurrentHashMap<Long, ReusableDecoder>()
+
+    fun getDecoderForCurrentThread(): ReusableDecoder {
+      val threadId = Thread.currentThread().id
+      return decoders.getOrPut(threadId) {
+        Log.d("AudioConcat", "  Created decoder for thread $threadId")
+        ReusableDecoder()
+      }
+    }
+
+    fun releaseAll() {
+      decoders.values.forEach { it.release() }
+      decoders.clear()
+      Log.d("AudioConcat", "Released all pooled decoders")
+    }
+  }
+
   private fun extractAudioConfig(filePath: String): AudioConfig {
     val extractor = MediaExtractor()
     try {
@@ -356,58 +437,48 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       return input
     }
 
+    val startTime = System.currentTimeMillis()
     val inputSampleCount = input.size / (2 * channelCount) // 16-bit = 2 bytes per sample
     val outputSampleCount = (inputSampleCount.toLong() * outputSampleRate / inputSampleRate).toInt()
     val output = ByteArray(outputSampleCount * 2 * channelCount)
 
-    // Use fixed-point arithmetic (16.16 format) to avoid floating-point operations
-    // This provides 3-5x performance improvement
-    val step = ((inputSampleRate.toLong() shl 16) / outputSampleRate).toInt()
-    var srcPos = 0
+    // Helper function to read a sample with bounds checking
+    fun readSample(sampleIndex: Int, channel: Int): Int {
+      val clampedIndex = sampleIndex.coerceIn(0, inputSampleCount - 1)
+      val idx = (clampedIndex * channelCount + channel) * 2
+      val unsigned = (input[idx].toInt() and 0xFF) or (input[idx + 1].toInt() shl 8)
+      return if (unsigned > 32767) unsigned - 65536 else unsigned
+    }
 
-    for (i in 0 until outputSampleCount) {
-      val srcIndex = srcPos shr 16
-      val fraction = srcPos and 0xFFFF // Fractional part in 16-bit fixed-point
+    // Use floating-point for better accuracy than fixed-point
+    val ratio = inputSampleRate.toDouble() / outputSampleRate.toDouble()
 
-      // Boundary check: ensure we don't go beyond input array
-      if (srcIndex >= inputSampleCount - 1) {
-        break
-      }
+    for (i in 0 until outputSampleCount) {
+      val srcPos = i * ratio
+      val srcIndex = srcPos.toInt()
+      val fraction = srcPos - srcIndex // Fractional part (0.0 to 1.0)
 
       for (ch in 0 until channelCount) {
-        // Get current and next sample indices
-        val idx1 = (srcIndex * channelCount + ch) * 2
-        val idx2 = ((srcIndex + 1) * channelCount + ch) * 2
-
-        // Read 16-bit samples (little-endian)
-        val sample1 = (input[idx1].toInt() and 0xFF) or (input[idx1 + 1].toInt() shl 8)
-        val sample2 = if (idx2 + 1 < input.size) {
-          (input[idx2].toInt() and 0xFF) or (input[idx2 + 1].toInt() shl 8)
-        } else {
-          sample1
-        }
-
-        // Convert to signed 16-bit
-        val s1 = if (sample1 > 32767) sample1 - 65536 else sample1
-        val s2 = if (sample2 > 32767) sample2 - 65536 else sample2
+        // Linear interpolation with floating-point precision
+        val s1 = readSample(srcIndex, ch).toDouble()
+        val s2 = readSample(srcIndex + 1, ch).toDouble()
 
-        // Linear interpolation using integer arithmetic
-        // interpolated = s1 + (s2 - s1) * fraction
-        // fraction is in 16.16 format, so we shift right by 16 after multiplication
-        val interpolated = s1 + (((s2 - s1) * fraction) shr 16)
+        // Linear interpolation: s1 + (s2 - s1) * fraction
+        val interpolated = s1 + (s2 - s1) * fraction
 
         // Clamp to 16-bit range
-        val clamped = interpolated.coerceIn(-32768, 32767)
+        val clamped = interpolated.toInt().coerceIn(-32768, 32767)
 
-        // Convert back to unsigned and write (little-endian)
+        // Write to output (little-endian)
         val outIdx = (i * channelCount + ch) * 2
         output[outIdx] = (clamped and 0xFF).toByte()
         output[outIdx + 1] = (clamped shr 8).toByte()
       }
-
-      srcPos += step
     }
 
+    val elapsedTime = System.currentTimeMillis() - startTime
+    Log.d("AudioConcat", "  Resampled ${inputSampleRate}Hz→${outputSampleRate}Hz, ${input.size / 1024}KB→${output.size / 1024}KB in ${elapsedTime}ms")
+
     return output
   }
 
@@ -477,7 +548,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     targetSampleRate: Int,
     targetChannelCount: Int,
     latch: CountDownLatch,
-    cache: PCMCache
+    cache: PCMCache,
+    decoderPool: DecoderPool? = null
   ) {
     try {
       // Check cache first
@@ -497,6 +569,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       var decoder: MediaCodec? = null
       val decodedChunks = mutableListOf<ByteArray>()
       var totalBytes = 0L
+      val shouldReleaseDecoder = (decoderPool == null) // Only release if not using pool
 
       try {
         extractor.setDataSource(filePath)
@@ -531,9 +604,17 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
         extractor.selectTrack(audioTrackIndex)
 
         val mime = audioFormat.getString(MediaFormat.KEY_MIME)!!
-        decoder = MediaCodec.createDecoderByType(mime)
-        decoder.configure(audioFormat, null, null, 0)
-        decoder.start()
+
+        // Use decoder pool if available, otherwise create new decoder
+        decoder = if (decoderPool != null) {
+          val reusableDecoder = decoderPool.getDecoderForCurrentThread()
+          reusableDecoder.getOrCreateDecoder(mime, audioFormat)
+        } else {
+          val newDecoder = MediaCodec.createDecoderByType(mime)
+          newDecoder.configure(audioFormat, null, null, 0)
+          newDecoder.start()
+          newDecoder
+        }
 
         val bufferInfo = MediaCodec.BufferInfo()
         var isEOS = false
@@ -596,8 +677,11 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
         }
 
       } finally {
-        decoder?.stop()
-        decoder?.release()
+        // Only stop/release decoder if not using pool
+        if (shouldReleaseDecoder) {
+          decoder?.stop()
+          decoder?.release()
+        }
         extractor.release()
       }
     } catch (e: Exception) {
@@ -613,10 +697,13 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     encoder: StreamingEncoder,
     isLastFile: Boolean,
     targetSampleRate: Int,
-    targetChannelCount: Int
+    targetChannelCount: Int,
+    reusableDecoder: ReusableDecoder? = null
   ) {
+    val startTime = System.currentTimeMillis()
     val extractor = MediaExtractor()
     var decoder: MediaCodec? = null
+    val shouldReleaseDecoder = (reusableDecoder == null) // Only release if not reusing
 
     try {
       extractor.setDataSource(filePath)
@@ -651,9 +738,16 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       extractor.selectTrack(audioTrackIndex)
 
       val mime = audioFormat.getString(MediaFormat.KEY_MIME)!!
-      decoder = MediaCodec.createDecoderByType(mime)
-      decoder.configure(audioFormat, null, null, 0)
-      decoder.start()
+
+      // Use reusable decoder if provided, otherwise create a new one
+      decoder = if (reusableDecoder != null) {
+        reusableDecoder.getOrCreateDecoder(mime, audioFormat)
+      } else {
+        val newDecoder = MediaCodec.createDecoderByType(mime)
+        newDecoder.configure(audioFormat, null, null, 0)
+        newDecoder.start()
+        newDecoder
+      }
 
       val bufferInfo = MediaCodec.BufferInfo()
       var isEOS = false
@@ -706,9 +800,14 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       }
 
     } finally {
-      decoder?.stop()
-      decoder?.release()
+      // Only stop/release decoder if we created it locally (not reusing)
+      if (shouldReleaseDecoder) {
+        decoder?.stop()
+        decoder?.release()
+      }
       extractor.release()
+      val elapsedTime = System.currentTimeMillis() - startTime
+      Log.d("AudioConcat", "  Decoded file in ${elapsedTime}ms")
     }
   }
 
@@ -833,6 +932,10 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     val latch = CountDownLatch(optimizedFiles.size)
     val sequenceCounter = AtomicInteger(0)
 
+    // Create decoder pool for reuse across threads
+    val decoderPool = DecoderPool()
+    Log.d("AudioConcat", "Created decoder pool for parallel processing ($numThreads threads)")
+
     try {
       // Submit decode tasks for unique files only
       optimizedFiles.forEachIndexed { optIndex, (index, filePath) ->
@@ -842,7 +945,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
             sequenceCounter.addAndGet(1000000)
 
             Log.d("AudioConcat", "Starting parallel decode [$index]: $filePath")
-            parallelDecodeToQueue(filePath, pcmQueue, fileSequenceStart, targetSampleRate, targetChannelCount, latch, cache)
+            parallelDecodeToQueue(filePath, pcmQueue, fileSequenceStart, targetSampleRate, targetChannelCount, latch, cache, decoderPool)
 
             // Mark end with duplicate count
             val repeatCount = consecutiveDuplicates[optIndex] ?: 1
@@ -900,6 +1003,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       Log.d("AudioConcat", "All parallel decode tasks completed")
 
     } finally {
+      decoderPool.releaseAll()
       executor.shutdown()
     }
   }
@@ -1032,17 +1136,24 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
   }
 
   override fun concatAudioFiles(data: ReadableArray, outputPath: String, promise: Promise) {
+    val totalStartTime = System.currentTimeMillis()
+    Log.d("AudioConcat", "========== Audio Concat Started ==========")
+
     try {
       if (data.size() == 0) {
         promise.reject("EMPTY_DATA", "Data array is empty")
         return
       }
 
+      // Parse data
+      val parseStartTime = System.currentTimeMillis()
       val parsedData = parseAudioData(data)
-      Log.d("AudioConcat", "Streaming merge of ${parsedData.size} items")
+      val parseTime = System.currentTimeMillis() - parseStartTime
+      Log.d("AudioConcat", "✓ Parsed ${parsedData.size} items in ${parseTime}ms")
       Log.d("AudioConcat", "Output: $outputPath")
 
       // Get audio config from first audio file
+      val configStartTime = System.currentTimeMillis()
       var audioConfig: AudioConfig? = null
       for (item in parsedData) {
         if (item is AudioDataOrSilence.AudioFile) {
@@ -1056,10 +1167,21 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
         return
       }
 
-      Log.d("AudioConcat", "Audio config: ${audioConfig.sampleRate}Hz, ${audioConfig.channelCount}ch, ${audioConfig.bitRate}bps")
+      val configTime = System.currentTimeMillis() - configStartTime
+
+      // Force output sample rate to 24kHz for optimal performance
+      val outputSampleRate = 24000
+      Log.d("AudioConcat", "✓ Extracted audio config in ${configTime}ms: ${audioConfig.channelCount}ch, ${audioConfig.bitRate}bps")
+      Log.d("AudioConcat", "Output sample rate: ${outputSampleRate}Hz (24kHz optimized)")
+
+      // Create modified config with fixed sample rate
+      val outputAudioConfig = AudioConfig(outputSampleRate, audioConfig.channelCount, audioConfig.bitRate)
 
       // Analyze duplicates to determine cache strategy
-      val duplicateAnalysis = analyzeDuplicates(parsedData, audioConfig)
+      val analysisStartTime = System.currentTimeMillis()
+      val duplicateAnalysis = analyzeDuplicates(parsedData, outputAudioConfig)
+      val analysisTime = System.currentTimeMillis() - analysisStartTime
+      Log.d("AudioConcat", "✓ Analyzed duplicates in ${analysisTime}ms")
 
       // Create cache instance with intelligent caching strategy
       val cache = PCMCache(duplicateAnalysis.duplicateFiles, duplicateAnalysis.duplicateSilence)
@@ -1070,9 +1192,9 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
         outputFile.delete()
       }
 
-      // Create streaming encoder
+      // Create streaming encoder with fixed 24kHz sample rate
       val encoder = StreamingEncoder(
-        audioConfig.sampleRate,
+        outputSampleRate,
         audioConfig.channelCount,
         audioConfig.bitRate,
         outputPath
@@ -1096,9 +1218,10 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
 
         // Decide whether to use parallel or sequential processing
         val useParallel = audioFileItems.size >= 10 // Use parallel for 10+ files
+        val processingStartTime = System.currentTimeMillis()
 
         if (useParallel) {
-          Log.d("AudioConcat", "Using parallel processing for ${audioFileItems.size} audio files")
+          Log.d("AudioConcat", "→ Using parallel processing for ${audioFileItems.size} audio files")
 
           // Process interleaved patterns optimally
           val processedIndices = mutableSetOf<Int>()
@@ -1121,7 +1244,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
               val latch = CountDownLatch(1)
               val seqStart = AtomicInteger(0)
 
-              parallelDecodeToQueue(filePath, tempQueue, seqStart, audioConfig.sampleRate, audioConfig.channelCount, latch, cache)
+              parallelDecodeToQueue(filePath, tempQueue, seqStart, outputSampleRate, audioConfig.channelCount, latch, cache)
 
               // Collect chunks
               var collecting = true
@@ -1203,7 +1326,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
                   parallelProcessAudioFiles(
                     consecutiveFiles,
                     encoder,
-                    audioConfig.sampleRate,
+                    outputSampleRate,
                     audioConfig.channelCount,
                     cache,
                     numThreads = optimalThreads
@@ -1218,7 +1341,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
                 streamEncodeSilence(
                   durationMs,
                   encoder,
-                  audioConfig.sampleRate,
+                  outputSampleRate,
                   audioConfig.channelCount,
                   cache
                 )
@@ -1226,47 +1349,66 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
             }
           }
         } else {
-          Log.d("AudioConcat", "Using sequential processing for ${audioFileItems.size} audio files")
+          Log.d("AudioConcat", "→ Using sequential processing for ${audioFileItems.size} audio files")
 
-          // Process each item sequentially (original behavior)
-          for ((index, item) in parsedData.withIndex()) {
-            when (item) {
-              is AudioDataOrSilence.AudioFile -> {
-                val filePath = item.filePath
-                Log.d("AudioConcat", "Item $index: Streaming decode $filePath")
+          // Create a reusable decoder for sequential processing
+          val reusableDecoder = ReusableDecoder()
+          Log.d("AudioConcat", "Created reusable decoder for sequential processing")
 
-                val isLastFile = (index == parsedData.size - 1)
-                streamDecodeAudioFile(
-                  filePath,
-                  encoder,
-                  isLastFile,
-                  audioConfig.sampleRate,
-                  audioConfig.channelCount
-                )
-              }
+          try {
+            // Process each item sequentially (with decoder reuse)
+            for ((index, item) in parsedData.withIndex()) {
+              when (item) {
+                is AudioDataOrSilence.AudioFile -> {
+                  val filePath = item.filePath
+                  Log.d("AudioConcat", "Item $index: Streaming decode $filePath")
+
+                  val isLastFile = (index == parsedData.size - 1)
+                  streamDecodeAudioFile(
+                    filePath,
+                    encoder,
+                    isLastFile,
+                    outputSampleRate,
+                    audioConfig.channelCount,
+                    reusableDecoder
+                  )
+                }
 
-              is AudioDataOrSilence.Silence -> {
-                val durationMs = item.durationMs
-                Log.d("AudioConcat", "Item $index: Streaming silence ${durationMs}ms")
+                is AudioDataOrSilence.Silence -> {
+                  val durationMs = item.durationMs
+                  Log.d("AudioConcat", "Item $index: Streaming silence ${durationMs}ms")
 
-                streamEncodeSilence(
-                  durationMs,
-                  encoder,
-                  audioConfig.sampleRate,
-                  audioConfig.channelCount,
-                  cache
-                )
+                  streamEncodeSilence(
+                    durationMs,
+                    encoder,
+                    outputSampleRate,
+                    audioConfig.channelCount,
+                    cache
+                  )
+                }
               }
             }
+          } finally {
+            // Release the reusable decoder when done
+            reusableDecoder.release()
+            Log.d("AudioConcat", "Released reusable decoder")
           }
         }
 
+        val processingTime = System.currentTimeMillis() - processingStartTime
+        Log.d("AudioConcat", "✓ Processing completed in ${processingTime}ms")
+
         // Finish encoding
+        val encodingFinishStartTime = System.currentTimeMillis()
         encoder.finish()
+        val encodingFinishTime = System.currentTimeMillis() - encodingFinishStartTime
+        Log.d("AudioConcat", "✓ Encoding finalized in ${encodingFinishTime}ms")
 
         // Log cache statistics
         Log.d("AudioConcat", "Cache statistics: ${cache.getStats()}")
 
+        val totalTime = System.currentTimeMillis() - totalStartTime
+        Log.d("AudioConcat", "========== Total Time: ${totalTime}ms (${totalTime / 1000.0}s) ==========")
         Log.d("AudioConcat", "Successfully merged audio to $outputPath")
         promise.resolve(outputPath)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-audio-concat",
-  "version": "0.5.0",
+  "version": "0.6.0",
   "description": "audio-concat for react-native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",