react-native-audio-concat 0.6.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
@@ -165,6 +166,59 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     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
@@ -172,7 +226,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
         // Flush the decoder to reset its state
         try {
           decoder!!.flush()
-          Log.d("AudioConcat", "  Reused decoder for $mimeType")
+          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}")
@@ -183,15 +238,23 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       // 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()
+      // 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
 
-      Log.d("AudioConcat", "  Created new decoder for $mimeType")
       return newDecoder
     }
 
@@ -281,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
@@ -298,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
@@ -317,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()
 
@@ -341,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
         }
       }
 
@@ -407,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)
@@ -417,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()
 
@@ -496,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 -> {
@@ -806,8 +974,16 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
         decoder?.release()
       }
       extractor.release()
+
+      // Performance metrics
       val elapsedTime = System.currentTimeMillis() - startTime
-      Log.d("AudioConcat", "  Decoded file in ${elapsedTime}ms")
+      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)")
     }
   }
 
@@ -1183,8 +1359,17 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       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)
@@ -1216,12 +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>()
@@ -1274,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)
@@ -1286,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)
@@ -1321,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,
-                    outputSampleRate,
-                    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
                 }
               }

package/package.json

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