react-native-audio-concat 0.5.0 → 0.7.0

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

@@ -7,6 +7,7 @@ import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.module.annotations.ReactModule
 import android.media.MediaCodec
 import android.media.MediaCodecInfo
+import android.media.MediaCodecList
 import android.media.MediaExtractor
 import android.media.MediaFormat
 import android.media.MediaMuxer
@@ -160,6 +161,149 @@ 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
+    private var isHardwareDecoder: Boolean = false
+
+    /**
+     * Try to create a hardware decoder for better performance
+     * Hardware decoders are typically 2-10x faster than software decoders
+     */
+    private fun createHardwareDecoder(mimeType: String, format: MediaFormat): MediaCodec? {
+      try {
+        val codecList = MediaCodecList(MediaCodecList.REGULAR_CODECS)
+
+        for (codecInfo in codecList.codecInfos) {
+          // Skip encoders
+          if (codecInfo.isEncoder) continue
+
+          // Check if this codec supports our mime type
+          if (!codecInfo.supportedTypes.any { it.equals(mimeType, ignoreCase = true) }) {
+            continue
+          }
+
+          // Hardware decoder identification by vendor prefix
+          val isHardware = codecInfo.name.let { name ->
+            name.startsWith("OMX.qcom") ||      // Qualcomm (most common)
+            name.startsWith("OMX.MTK") ||       // MediaTek
+            name.startsWith("OMX.Exynos") ||    // Samsung Exynos
+            name.startsWith("OMX.SEC") ||       // Samsung
+            name.startsWith("OMX.hisi") ||      // Huawei HiSilicon
+            name.startsWith("c2.qti") ||        // Qualcomm C2
+            name.startsWith("c2.mtk") ||        // MediaTek C2
+            name.startsWith("c2.exynos") ||     // Samsung C2
+            (name.contains("hardware", ignoreCase = true) &&
+             !name.contains("google", ignoreCase = true))
+          }
+
+          if (isHardware) {
+            try {
+              val codec = MediaCodec.createByCodecName(codecInfo.name)
+              codec.configure(format, null, null, 0)
+              codec.start()
+
+              Log.d("AudioConcat", "  ✓ Created HARDWARE decoder: ${codecInfo.name}")
+              return codec
+            } catch (e: Exception) {
+              Log.w("AudioConcat", "  ✗ HW decoder ${codecInfo.name} failed: ${e.message}")
+              // Continue to try next hardware decoder
+            }
+          }
+        }
+      } catch (e: Exception) {
+        Log.w("AudioConcat", "  Hardware decoder search failed: ${e.message}")
+      }
+
+      return 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()
+          val type = if (isHardwareDecoder) "HW" else "SW"
+          Log.d("AudioConcat", "  ↻ Reused $type 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
+
+      // Try hardware decoder first (2-10x faster)
+      var newDecoder = createHardwareDecoder(mimeType, format)
+      isHardwareDecoder = (newDecoder != null)
+
+      // Fallback to software decoder
+      if (newDecoder == null) {
+        newDecoder = MediaCodec.createDecoderByType(mimeType)
+        newDecoder.configure(format, null, null, 0)
+        newDecoder.start()
+        Log.d("AudioConcat", "  ⚠ Created SOFTWARE decoder for $mimeType (no HW available)")
+        isHardwareDecoder = false
+      }
+
+      decoder = newDecoder
+      currentMimeType = mimeType
+      currentFormat = format
+
+      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 {
@@ -200,6 +344,10 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     private val channelCount: Int
     private val maxChunkSize: Int
 
+    // Performance tracking
+    private var totalBufferWaitTimeMs = 0L
+    private var bufferWaitCount = 0
+
     init {
       this.sampleRate = sampleRate
       this.channelCount = channelCount
@@ -217,8 +365,9 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       val samplesPerFrame = 1024
       val bytesPerSample = channelCount * 2 // 16-bit PCM
       val optimalBufferSize = samplesPerFrame * bytesPerSample
-      // Use at least the optimal size, but allow for some overhead
-      val bufferSize = (optimalBufferSize * 1.5).toInt().coerceAtLeast(16384)
+      // OPTIMIZATION: Increased buffer size for better throughput
+      // Larger buffers reduce dequeue operations and improve encoder efficiency
+      val bufferSize = (optimalBufferSize * 4.0).toInt().coerceAtLeast(65536)
       outputFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, bufferSize)
 
       // Store for use in encodePCMChunk
@@ -236,14 +385,23 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     fun encodePCMChunk(pcmData: ByteArray, isLast: Boolean = false): Boolean {
       // Split large PCM data into smaller chunks that fit in encoder buffer (use configured size)
       var offset = 0
+      var buffersQueued = 0  // Track queued buffers for batch draining
 
       while (offset < pcmData.size) {
         val chunkSize = minOf(maxChunkSize, pcmData.size - offset)
         val isLastChunk = (offset + chunkSize >= pcmData.size) && isLast
 
         // Feed PCM data chunk to encoder (reduced timeout for better throughput)
+        val bufferWaitStart = System.currentTimeMillis()
         val inputBufferIndex = encoder.dequeueInputBuffer(1000)
+        val bufferWaitTime = System.currentTimeMillis() - bufferWaitStart
+
         if (inputBufferIndex >= 0) {
+          if (bufferWaitTime > 5) {
+            totalBufferWaitTimeMs += bufferWaitTime
+            bufferWaitCount++
+          }
+
           val inputBuffer = encoder.getInputBuffer(inputBufferIndex)!!
           val bufferCapacity = inputBuffer.capacity()
 
@@ -260,14 +418,20 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
           encoder.queueInputBuffer(inputBufferIndex, 0, actualChunkSize, presentationTimeUs, flags)
 
           offset += actualChunkSize
+          buffersQueued++
         } else {
+          totalBufferWaitTimeMs += bufferWaitTime
+          bufferWaitCount++
           // Buffer not available, drain first
           drainEncoder(false)
+          buffersQueued = 0  // Reset counter after forced drain
         }
 
-        // Drain encoder output periodically
-        if (offset < pcmData.size || !isLastChunk) {
+        // OPTIMIZATION: Batch drain - only drain every 4 buffers instead of every buffer
+        // This reduces overhead while keeping encoder pipeline flowing
+        if (buffersQueued >= 4 || isLastChunk || offset >= pcmData.size) {
           drainEncoder(false)
+          buffersQueued = 0
         }
       }
 
@@ -326,6 +490,14 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       }
     }
 
+    fun getEncoderStats(): String {
+      val avgWaitTime = if (bufferWaitCount > 0) {
+        String.format("%.2f", totalBufferWaitTimeMs.toFloat() / bufferWaitCount)
+      } else "0.00"
+
+      return "Buffer waits: $bufferWaitCount, Total wait: ${totalBufferWaitTimeMs}ms, Avg: ${avgWaitTime}ms"
+    }
+
     fun finish() {
       // Signal end of stream (reduced timeout)
       val inputBufferIndex = encoder.dequeueInputBuffer(1000)
@@ -336,6 +508,9 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       // Drain remaining data
       drainEncoder(true)
 
+      // Log encoder performance stats
+      Log.d("AudioConcat", "Encoder stats: ${getEncoderStats()}")
+
       encoder.stop()
       encoder.release()
 
@@ -356,58 +531,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
-        }
+        // Linear interpolation with floating-point precision
+        val s1 = readSample(srcIndex, ch).toDouble()
+        val s2 = readSample(srcIndex + 1, ch).toDouble()
 
-        // 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 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
   }
 
@@ -425,33 +590,107 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
 
     when {
       inputChannels == 1 && outputChannels == 2 -> {
-        // Mono to Stereo: duplicate the channel
-        for (i in 0 until sampleCount) {
+        // OPTIMIZED: Mono to Stereo using batch copy with unrolled loop
+        // Process 4 samples at a time for better cache locality
+        val batchSize = 4
+        val fullBatches = sampleCount / batchSize
+        var i = 0
+
+        // Process batches of 4 samples
+        for (batch in 0 until fullBatches) {
+          val baseIdx = i * 2
+          val baseDst = i * 4
+
+          // Sample 1
+          output[baseDst] = input[baseIdx]
+          output[baseDst + 1] = input[baseIdx + 1]
+          output[baseDst + 2] = input[baseIdx]
+          output[baseDst + 3] = input[baseIdx + 1]
+
+          // Sample 2
+          output[baseDst + 4] = input[baseIdx + 2]
+          output[baseDst + 5] = input[baseIdx + 3]
+          output[baseDst + 6] = input[baseIdx + 2]
+          output[baseDst + 7] = input[baseIdx + 3]
+
+          // Sample 3
+          output[baseDst + 8] = input[baseIdx + 4]
+          output[baseDst + 9] = input[baseIdx + 5]
+          output[baseDst + 10] = input[baseIdx + 4]
+          output[baseDst + 11] = input[baseIdx + 5]
+
+          // Sample 4
+          output[baseDst + 12] = input[baseIdx + 6]
+          output[baseDst + 13] = input[baseIdx + 7]
+          output[baseDst + 14] = input[baseIdx + 6]
+          output[baseDst + 15] = input[baseIdx + 7]
+
+          i += batchSize
+        }
+
+        // Process remaining samples
+        while (i < sampleCount) {
           val srcIdx = i * 2
           val dstIdx = i * 4
           output[dstIdx] = input[srcIdx]
           output[dstIdx + 1] = input[srcIdx + 1]
           output[dstIdx + 2] = input[srcIdx]
           output[dstIdx + 3] = input[srcIdx + 1]
+          i++
         }
       }
       inputChannels == 2 && outputChannels == 1 -> {
-        // Stereo to Mono: average the channels
-        for (i in 0 until sampleCount) {
+        // OPTIMIZED: Stereo to Mono with unrolled loop
+        val batchSize = 4
+        val fullBatches = sampleCount / batchSize
+        var i = 0
+
+        // Process batches of 4 samples
+        for (batch in 0 until fullBatches) {
+          val baseSrc = i * 4
+          val baseDst = i * 2
+
+          // Sample 1
+          var left = (input[baseSrc].toInt() and 0xFF) or (input[baseSrc + 1].toInt() shl 8)
+          var right = (input[baseSrc + 2].toInt() and 0xFF) or (input[baseSrc + 3].toInt() shl 8)
+          var avg = (((if (left > 32767) left - 65536 else left) + (if (right > 32767) right - 65536 else right)) shr 1)
+          output[baseDst] = (avg and 0xFF).toByte()
+          output[baseDst + 1] = (avg shr 8).toByte()
+
+          // Sample 2
+          left = (input[baseSrc + 4].toInt() and 0xFF) or (input[baseSrc + 5].toInt() shl 8)
+          right = (input[baseSrc + 6].toInt() and 0xFF) or (input[baseSrc + 7].toInt() shl 8)
+          avg = (((if (left > 32767) left - 65536 else left) + (if (right > 32767) right - 65536 else right)) shr 1)
+          output[baseDst + 2] = (avg and 0xFF).toByte()
+          output[baseDst + 3] = (avg shr 8).toByte()
+
+          // Sample 3
+          left = (input[baseSrc + 8].toInt() and 0xFF) or (input[baseSrc + 9].toInt() shl 8)
+          right = (input[baseSrc + 10].toInt() and 0xFF) or (input[baseSrc + 11].toInt() shl 8)
+          avg = (((if (left > 32767) left - 65536 else left) + (if (right > 32767) right - 65536 else right)) shr 1)
+          output[baseDst + 4] = (avg and 0xFF).toByte()
+          output[baseDst + 5] = (avg shr 8).toByte()
+
+          // Sample 4
+          left = (input[baseSrc + 12].toInt() and 0xFF) or (input[baseSrc + 13].toInt() shl 8)
+          right = (input[baseSrc + 14].toInt() and 0xFF) or (input[baseSrc + 15].toInt() shl 8)
+          avg = (((if (left > 32767) left - 65536 else left) + (if (right > 32767) right - 65536 else right)) shr 1)
+          output[baseDst + 6] = (avg and 0xFF).toByte()
+          output[baseDst + 7] = (avg shr 8).toByte()
+
+          i += batchSize
+        }
+
+        // Process remaining samples
+        while (i < sampleCount) {
           val srcIdx = i * 4
           val dstIdx = i * 2
-
           val left = (input[srcIdx].toInt() and 0xFF) or (input[srcIdx + 1].toInt() shl 8)
           val right = (input[srcIdx + 2].toInt() and 0xFF) or (input[srcIdx + 3].toInt() shl 8)
-
-          val leftSigned = if (left > 32767) left - 65536 else left
-          val rightSigned = if (right > 32767) right - 65536 else right
-
-          // Use bit shift instead of division for better performance (x / 2 = x >> 1)
-          val avg = ((leftSigned + rightSigned) shr 1).coerceIn(-32768, 32767)
-
+          val avg = (((if (left > 32767) left - 65536 else left) + (if (right > 32767) right - 65536 else right)) shr 1)
           output[dstIdx] = (avg and 0xFF).toByte()
           output[dstIdx + 1] = (avg shr 8).toByte()
+          i++
         }
       }
       else -> {
@@ -477,7 +716,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     targetSampleRate: Int,
     targetChannelCount: Int,
     latch: CountDownLatch,
-    cache: PCMCache
+    cache: PCMCache,
+    decoderPool: DecoderPool? = null
   ) {
     try {
       // Check cache first
@@ -497,6 +737,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 +772,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 +845,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 +865,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 +906,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 +968,22 @@ 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()
+
+      // Performance metrics
+      val elapsedTime = System.currentTimeMillis() - startTime
+      val fileSize = try { File(filePath).length() } catch (e: Exception) { 0L }
+      val fileSizeKB = fileSize / 1024
+      val decodingSpeedMBps = if (elapsedTime > 0) {
+        (fileSize / 1024.0 / 1024.0) / (elapsedTime / 1000.0)
+      } else 0.0
+
+      Log.d("AudioConcat", "  ⚡ Decoded ${fileSizeKB}KB in ${elapsedTime}ms (${String.format("%.2f", decodingSpeedMBps)} MB/s)")
     }
   }
 
@@ -833,6 +1108,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 +1121,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 +1179,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       Log.d("AudioConcat", "All parallel decode tasks completed")
 
     } finally {
+      decoderPool.releaseAll()
       executor.shutdown()
     }
   }
@@ -1032,17 +1312,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,13 +1343,33 @@ 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")
+
+      // Collect all unique audio files for pre-decode caching
+      val allAudioFiles = parsedData.filterIsInstance<AudioDataOrSilence.AudioFile>()
+        .map { it.filePath }
+        .distinct()
+
+      // Merge duplicate files with all unique files for comprehensive caching
+      // This ensures pre-decoded files are always cached, regardless of occurrence count
+      val filesToCache = (duplicateAnalysis.duplicateFiles + allAudioFiles).toSet()
 
       // Create cache instance with intelligent caching strategy
-      val cache = PCMCache(duplicateAnalysis.duplicateFiles, duplicateAnalysis.duplicateSilence)
+      val cache = PCMCache(filesToCache, duplicateAnalysis.duplicateSilence)
 
       // Delete existing output file
       val outputFile = File(outputPath)
@@ -1070,9 +1377,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
@@ -1094,11 +1401,160 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
           }
         }
 
+        // PRE-DECODE: Parallel decode all unique audio files to cache before processing
+        val uniqueAudioFiles = audioFileItems.map { it.second }.distinct()
+        val filesToPreDecode = uniqueAudioFiles.filter { cache.getAudioFile(it) == null }
+
+        if (filesToPreDecode.isNotEmpty()) {
+          val preDecodeStartTime = System.currentTimeMillis()
+          val cpuCores = Runtime.getRuntime().availableProcessors()
+          val preDecodeThreads = getOptimalThreadCount(filesToPreDecode.size)
+
+          Log.d("AudioConcat", "→ PRE-DECODE: ${filesToPreDecode.size} unique files using $preDecodeThreads threads (CPU cores: $cpuCores)")
+
+          val preDecodeExecutor = Executors.newFixedThreadPool(preDecodeThreads)
+          val preDecodeLatch = CountDownLatch(filesToPreDecode.size)
+          val preDecodePool = DecoderPool()
+
+          try {
+            filesToPreDecode.forEach { filePath ->
+              preDecodeExecutor.submit {
+                try {
+                  Log.d("AudioConcat", "  Pre-decoding: $filePath")
+
+                  // Decode directly to cache without intermediate queue
+                  val extractor = MediaExtractor()
+                  var totalBytes = 0L
+                  val decodedChunks = mutableListOf<ByteArray>()
+
+                  try {
+                    extractor.setDataSource(filePath)
+
+                    var audioTrackIndex = -1
+                    var audioFormat: MediaFormat? = null
+
+                    for (i in 0 until extractor.trackCount) {
+                      val format = extractor.getTrackFormat(i)
+                      val mime = format.getString(MediaFormat.KEY_MIME) ?: continue
+                      if (mime.startsWith("audio/")) {
+                        audioTrackIndex = i
+                        audioFormat = format
+                        break
+                      }
+                    }
+
+                    if (audioTrackIndex == -1 || audioFormat == null) {
+                      throw Exception("No audio track found in $filePath")
+                    }
+
+                    val sourceSampleRate = audioFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+                    val sourceChannelCount = audioFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+
+                    val needsResampling = sourceSampleRate != outputSampleRate
+                    val needsChannelConversion = sourceChannelCount != audioConfig.channelCount
+
+                    if (needsResampling || needsChannelConversion) {
+                      Log.d("AudioConcat", "  Parallel decode: $filePath - ${sourceSampleRate}Hz ${sourceChannelCount}ch -> ${outputSampleRate}Hz ${audioConfig.channelCount}ch")
+                    }
+
+                    extractor.selectTrack(audioTrackIndex)
+
+                    val mime = audioFormat.getString(MediaFormat.KEY_MIME)!!
+                    val reusableDecoder = preDecodePool.getDecoderForCurrentThread()
+                    val decoder = reusableDecoder.getOrCreateDecoder(mime, audioFormat)
+
+                    val bufferInfo = MediaCodec.BufferInfo()
+                    var isEOS = false
+
+                    while (!isEOS) {
+                      // Feed input
+                      val inputBufferIndex = decoder.dequeueInputBuffer(1000)
+                      if (inputBufferIndex >= 0) {
+                        val inputBuffer = decoder.getInputBuffer(inputBufferIndex)!!
+                        val sampleSize = extractor.readSampleData(inputBuffer, 0)
+
+                        if (sampleSize < 0) {
+                          decoder.queueInputBuffer(inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+                        } else {
+                          val presentationTimeUs = extractor.sampleTime
+                          decoder.queueInputBuffer(inputBufferIndex, 0, sampleSize, presentationTimeUs, 0)
+                          extractor.advance()
+                        }
+                      }
+
+                      // Get output
+                      val outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 1000)
+                      if (outputBufferIndex >= 0) {
+                        val outputBuffer = decoder.getOutputBuffer(outputBufferIndex)!!
+
+                        if (bufferInfo.size > 0) {
+                          var pcmData = ByteArray(bufferInfo.size)
+                          outputBuffer.get(pcmData)
+
+                          // Convert channel count if needed
+                          if (needsChannelConversion) {
+                            pcmData = convertChannelCount(pcmData, sourceChannelCount, audioConfig.channelCount)
+                          }
+
+                          // Resample if needed
+                          if (needsResampling) {
+                            pcmData = resamplePCM16(pcmData, sourceSampleRate, outputSampleRate, audioConfig.channelCount)
+                          }
+
+                          decodedChunks.add(pcmData)
+                          totalBytes += pcmData.size
+                        }
+
+                        decoder.releaseOutputBuffer(outputBufferIndex, false)
+
+                        if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                          isEOS = true
+                        }
+                      }
+                    }
+
+                    // Cache the decoded data
+                    if (decodedChunks.isNotEmpty()) {
+                      cache.putAudioFile(filePath, CachedPCMData(decodedChunks, totalBytes))
+                    }
+
+                  } finally {
+                    extractor.release()
+                  }
+
+                } catch (e: Exception) {
+                  Log.e("AudioConcat", "Error pre-decoding $filePath: ${e.message}", e)
+                } finally {
+                  preDecodeLatch.countDown()
+                }
+              }
+            }
+
+            // Wait for all pre-decoding to complete
+            preDecodeLatch.await()
+            preDecodePool.releaseAll()
+            preDecodeExecutor.shutdown()
+
+            val preDecodeTime = System.currentTimeMillis() - preDecodeStartTime
+            Log.d("AudioConcat", "✓ Pre-decode completed in ${preDecodeTime}ms")
+
+          } catch (e: Exception) {
+            Log.e("AudioConcat", "Error during pre-decode: ${e.message}", e)
+            preDecodePool.releaseAll()
+            preDecodeExecutor.shutdown()
+          }
+        } else {
+          Log.d("AudioConcat", "→ All audio files already cached, skipping pre-decode")
+        }
+
         // Decide whether to use parallel or sequential processing
-        val useParallel = audioFileItems.size >= 10 // Use parallel for 10+ files
+        // Parallel processing is beneficial even with few files due to multi-core CPUs
+        val useParallel = audioFileItems.size >= 3 // Use parallel for 3+ files (was 10)
+        val processingStartTime = System.currentTimeMillis()
 
         if (useParallel) {
-          Log.d("AudioConcat", "Using parallel processing for ${audioFileItems.size} audio files")
+          val cpuCores = Runtime.getRuntime().availableProcessors()
+          Log.d("AudioConcat", "→ Using PARALLEL processing for ${audioFileItems.size} audio files (CPU cores: $cpuCores)")
 
           // Process interleaved patterns optimally
           val processedIndices = mutableSetOf<Int>()
@@ -1121,7 +1577,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
@@ -1151,10 +1607,32 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
               }
 
             // Encode the pattern: file -> silence -> file -> silence -> ...
-            repeat(pattern.repeatCount) { iteration ->
-              // Encode file
+            // OPTIMIZATION: Batch chunks to reduce encoder call overhead
+            val patternStartTime = System.currentTimeMillis()
+
+            // Combine all chunks from the file into a single buffer
+            val combinedFileBuffer = if (pcmChunks.size > 10) {
+              val totalSize = pcmChunks.sumOf { it.size }
+              val buffer = ByteArray(totalSize)
+              var offset = 0
               pcmChunks.forEach { chunk ->
-                encoder.encodePCMChunk(chunk, false)
+                System.arraycopy(chunk, 0, buffer, offset, chunk.size)
+                offset += chunk.size
+              }
+              Log.d("AudioConcat", "  Batched ${pcmChunks.size} chunks into single buffer (${totalSize / 1024}KB)")
+              buffer
+            } else {
+              null
+            }
+
+            repeat(pattern.repeatCount) { iteration ->
+              // Encode file (batched or individual chunks)
+              if (combinedFileBuffer != null) {
+                encoder.encodePCMChunk(combinedFileBuffer, false)
+              } else {
+                pcmChunks.forEach { chunk ->
+                  encoder.encodePCMChunk(chunk, false)
+                }
               }
 
               // Encode silence (except after the last file)
@@ -1163,6 +1641,9 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
               }
             }
 
+            val patternTime = System.currentTimeMillis() - patternStartTime
+            Log.d("AudioConcat", "  Encoded interleaved pattern in ${patternTime}ms")
+
             // Mark these indices as processed
             pattern.indices.forEach { idx ->
               processedIndices.add(idx)
@@ -1198,16 +1679,71 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
                 }
 
                 if (consecutiveFiles.isNotEmpty()) {
-                  val optimalThreads = getOptimalThreadCount(consecutiveFiles.size)
-                  Log.d("AudioConcat", "Using $optimalThreads threads for ${consecutiveFiles.size} files (CPU cores: ${Runtime.getRuntime().availableProcessors()})")
-                  parallelProcessAudioFiles(
-                    consecutiveFiles,
-                    encoder,
-                    audioConfig.sampleRate,
-                    audioConfig.channelCount,
-                    cache,
-                    numThreads = optimalThreads
-                  )
+                  // OPTIMIZATION: Fast path for cached files - avoid thread pool overhead
+                  val allCached = consecutiveFiles.all { (_, filePath) -> cache.getAudioFile(filePath) != null }
+
+                  if (allCached) {
+                    // Direct encoding from cache without parallel processing overhead
+                    val startTime = System.currentTimeMillis()
+                    Log.d("AudioConcat", "Fast path: encoding ${consecutiveFiles.size} cached files directly")
+
+                    consecutiveFiles.forEach { (itemIdx, filePath) ->
+                      val cachedData = cache.getAudioFile(filePath)!!
+                      val chunkCount = cachedData.chunks.size
+
+                      Log.d("AudioConcat", "  File[$itemIdx]: ${cachedData.totalBytes / 1024}KB in $chunkCount chunks")
+
+                      val encodeStartTime = System.currentTimeMillis()
+
+                      // OPTIMIZATION: Batch all chunks into single buffer to reduce encoder call overhead
+                      // Instead of 300+ calls at ~2.5ms each, make 1 call
+                      if (chunkCount > 10) {
+                        // Many small chunks - combine into single buffer for massive speedup
+                        val batchStartTime = System.currentTimeMillis()
+                        val combinedBuffer = ByteArray(cachedData.totalBytes.toInt())
+                        var offset = 0
+
+                        cachedData.chunks.forEach { chunk ->
+                          System.arraycopy(chunk, 0, combinedBuffer, offset, chunk.size)
+                          offset += chunk.size
+                        }
+
+                        val batchTime = System.currentTimeMillis() - batchStartTime
+                        Log.d("AudioConcat", "    Batched $chunkCount chunks in ${batchTime}ms")
+
+                        // Single encoder call instead of 300+
+                        encoder.encodePCMChunk(combinedBuffer, false)
+                      } else {
+                        // Few chunks - encode directly (rare case)
+                        cachedData.chunks.forEach { chunk ->
+                          encoder.encodePCMChunk(chunk, false)
+                        }
+                      }
+
+                      val encodeTime = System.currentTimeMillis() - encodeStartTime
+                      val throughputMBps = if (encodeTime > 0) {
+                        (cachedData.totalBytes / 1024.0 / 1024.0) / (encodeTime / 1000.0)
+                      } else 0.0
+
+                      Log.d("AudioConcat", "    Encoded in ${encodeTime}ms (${String.format("%.2f", throughputMBps)} MB/s)")
+                    }
+
+                    val elapsedTime = System.currentTimeMillis() - startTime
+                    val totalKB = consecutiveFiles.sumOf { (_, filePath) -> cache.getAudioFile(filePath)!!.totalBytes } / 1024
+                    Log.d("AudioConcat", "  ⚡ Encoded ${consecutiveFiles.size} cached files (${totalKB}KB) in ${elapsedTime}ms")
+                  } else {
+                    // Standard parallel processing for non-cached files
+                    val optimalThreads = getOptimalThreadCount(consecutiveFiles.size)
+                    Log.d("AudioConcat", "Using $optimalThreads threads for ${consecutiveFiles.size} files (CPU cores: ${Runtime.getRuntime().availableProcessors()})")
+                    parallelProcessAudioFiles(
+                      consecutiveFiles,
+                      encoder,
+                      outputSampleRate,
+                      audioConfig.channelCount,
+                      cache,
+                      numThreads = optimalThreads
+                    )
+                  }
                   audioFileIdx = currentIdx
                 }
               }
@@ -1218,7 +1754,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
                 streamEncodeSilence(
                   durationMs,
                   encoder,
-                  audioConfig.sampleRate,
+                  outputSampleRate,
                   audioConfig.channelCount,
                   cache
                 )
@@ -1226,47 +1762,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.7.0",
   "description": "audio-concat for react-native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",