react-native-audio-concat 0.4.0 → 0.6.0

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

@@ -57,15 +57,61 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     val channelCount: Int
   )
 
+  // Buffer pool for silence generation to reduce memory allocations
+  private object SilenceBufferPool {
+    private val pool = ConcurrentHashMap<Int, ByteArray>()
+    private val standardSizes = listOf(4096, 8192, 16384, 32768, 65536, 131072)
+
+    init {
+      // Pre-allocate common silence buffer sizes
+      standardSizes.forEach { size ->
+        pool[size] = ByteArray(size)
+      }
+      Log.d("AudioConcat", "SilenceBufferPool initialized with ${standardSizes.size} standard sizes")
+    }
+
+    fun getBuffer(requestedSize: Int): ByteArray {
+      // Find the smallest standard size that fits the request
+      val standardSize = standardSizes.firstOrNull { it >= requestedSize }
+
+      return if (standardSize != null) {
+        // Return pooled buffer (already zeroed)
+        pool.getOrPut(standardSize) { ByteArray(standardSize) }
+      } else {
+        // Size too large for pool, create new buffer
+        ByteArray(requestedSize)
+      }
+    }
+
+    fun clear() {
+      pool.clear()
+      Log.d("AudioConcat", "SilenceBufferPool cleared")
+    }
+  }
+
   private class PCMCache(
     private val shouldCacheFile: Set<String>,
     private val shouldCacheSilence: Set<SilenceCacheKey>
   ) {
     private val audioFileCache = ConcurrentHashMap<String, CachedPCMData>()
     private val silenceCache = ConcurrentHashMap<SilenceCacheKey, ByteArray>()
-    private val maxCacheSizeMB = 100 // Limit cache to 100MB
     private var currentCacheSizeBytes = 0L
 
+    // Dynamic cache size based on available memory
+    private val maxCacheSizeBytes: Long
+      get() {
+        val runtime = Runtime.getRuntime()
+        val maxMemory = runtime.maxMemory()
+        val usedMemory = runtime.totalMemory() - runtime.freeMemory()
+        val availableMemory = maxMemory - usedMemory
+
+        // Use 20% of available memory for cache, but constrain between 50MB and 200MB
+        val dynamicCacheMB = (availableMemory / (1024 * 1024) * 0.2).toLong()
+        val cacheMB = dynamicCacheMB.coerceIn(50, 200)
+
+        return cacheMB * 1024 * 1024
+      }
+
     fun getAudioFile(filePath: String): CachedPCMData? {
       return audioFileCache[filePath]
     }
@@ -76,15 +122,16 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
         return
       }
 
-      // Check cache size limit
-      if (currentCacheSizeBytes + data.totalBytes > maxCacheSizeMB * 1024 * 1024) {
-        Log.d("AudioConcat", "Cache full, not caching: $filePath")
+      // Check cache size limit (dynamic)
+      if (currentCacheSizeBytes + data.totalBytes > maxCacheSizeBytes) {
+        val maxCacheMB = maxCacheSizeBytes / (1024 * 1024)
+        Log.d("AudioConcat", "Cache full ($maxCacheMB MB), not caching: $filePath")
         return
       }
 
       audioFileCache[filePath] = data
       currentCacheSizeBytes += data.totalBytes
-      Log.d("AudioConcat", "Cached audio file: $filePath (${data.totalBytes / 1024}KB)")
+      Log.d("AudioConcat", "Cached audio file: $filePath (${data.totalBytes / 1024}KB, total: ${currentCacheSizeBytes / 1024}KB)")
     }
 
     fun getSilence(key: SilenceCacheKey): ByteArray? {
@@ -113,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 {
@@ -151,6 +279,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     private var totalPresentationTimeUs = 0L
     private val sampleRate: Int
     private val channelCount: Int
+    private val maxChunkSize: Int
 
     init {
       this.sampleRate = sampleRate
@@ -163,7 +292,20 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       )
       outputFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC)
       outputFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate)
-      outputFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 65536) // Increased from 16384
+
+      // Optimized buffer size based on audio parameters
+      // Target: ~1024 samples per frame for optimal AAC encoding
+      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)
+      outputFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, bufferSize)
+
+      // Store for use in encodePCMChunk
+      this.maxChunkSize = bufferSize
+
+      Log.d("AudioConcat", "Encoder buffer size: $bufferSize bytes (${samplesPerFrame} samples, ${sampleRate}Hz, ${channelCount}ch)")
 
       encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC)
       encoder.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
@@ -173,16 +315,15 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     }
 
     fun encodePCMChunk(pcmData: ByteArray, isLast: Boolean = false): Boolean {
-      // Split large PCM data into smaller chunks that fit in encoder buffer
-      val maxChunkSize = 65536 // Match KEY_MAX_INPUT_SIZE
+      // Split large PCM data into smaller chunks that fit in encoder buffer (use configured size)
       var offset = 0
 
       while (offset < pcmData.size) {
         val chunkSize = minOf(maxChunkSize, pcmData.size - offset)
         val isLastChunk = (offset + chunkSize >= pcmData.size) && isLast
 
-        // Feed PCM data chunk to encoder
-        val inputBufferIndex = encoder.dequeueInputBuffer(10000)
+        // Feed PCM data chunk to encoder (reduced timeout for better throughput)
+        val inputBufferIndex = encoder.dequeueInputBuffer(1000)
         if (inputBufferIndex >= 0) {
           val inputBuffer = encoder.getInputBuffer(inputBufferIndex)!!
           val bufferCapacity = inputBuffer.capacity()
@@ -221,7 +362,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
 
     private fun drainEncoder(endOfStream: Boolean) {
       while (true) {
-        val outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, if (endOfStream) 10000 else 0)
+        // Use shorter timeout for better responsiveness
+        val outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, if (endOfStream) 1000 else 0)
 
         when (outputBufferIndex) {
           MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
@@ -266,8 +408,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     }
 
     fun finish() {
-      // Signal end of stream
-      val inputBufferIndex = encoder.dequeueInputBuffer(10000)
+      // Signal end of stream (reduced timeout)
+      val inputBufferIndex = encoder.dequeueInputBuffer(1000)
       if (inputBufferIndex >= 0) {
         encoder.queueInputBuffer(inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
       }
@@ -295,51 +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)
 
+    // 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
+    }
+
+    // Use floating-point for better accuracy than fixed-point
     val ratio = inputSampleRate.toDouble() / outputSampleRate.toDouble()
 
     for (i in 0 until outputSampleCount) {
       val srcPos = i * ratio
       val srcIndex = srcPos.toInt()
-      val fraction = srcPos - srcIndex
+      val fraction = srcPos - srcIndex // Fractional part (0.0 to 1.0)
 
       for (ch in 0 until channelCount) {
-        // Get current and next sample
-        val idx1 = (srcIndex * channelCount + ch) * 2
-        val idx2 = ((srcIndex + 1) * channelCount + ch) * 2
-
-        val sample1 = if (idx1 + 1 < input.size) {
-          (input[idx1].toInt() and 0xFF) or (input[idx1 + 1].toInt() shl 8)
-        } else {
-          0
-        }
+        // Linear interpolation with floating-point precision
+        val s1 = readSample(srcIndex, ch).toDouble()
+        val s2 = readSample(srcIndex + 1, ch).toDouble()
 
-        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
-        val interpolated = (s1 + (s2 - s1) * fraction).toInt()
+        // 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
+        // Write to output (little-endian)
         val outIdx = (i * channelCount + ch) * 2
         output[outIdx] = (clamped and 0xFF).toByte()
         output[outIdx + 1] = (clamped shr 8).toByte()
       }
     }
 
+    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
   }
 
@@ -379,7 +518,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
           val leftSigned = if (left > 32767) left - 65536 else left
           val rightSigned = if (right > 32767) right - 65536 else right
 
-          val avg = ((leftSigned + rightSigned) / 2).coerceIn(-32768, 32767)
+          // Use bit shift instead of division for better performance (x / 2 = x >> 1)
+          val avg = ((leftSigned + rightSigned) shr 1).coerceIn(-32768, 32767)
 
           output[dstIdx] = (avg and 0xFF).toByte()
           output[dstIdx + 1] = (avg shr 8).toByte()
@@ -408,7 +548,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     targetSampleRate: Int,
     targetChannelCount: Int,
     latch: CountDownLatch,
-    cache: PCMCache
+    cache: PCMCache,
+    decoderPool: DecoderPool? = null
   ) {
     try {
       // Check cache first
@@ -428,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)
@@ -462,16 +604,24 @@ 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
 
         while (!isEOS) {
-          // Feed input to decoder
-          val inputBufferIndex = decoder.dequeueInputBuffer(10000)
+          // Feed input to decoder (reduced timeout for faster processing)
+          val inputBufferIndex = decoder.dequeueInputBuffer(1000)
           if (inputBufferIndex >= 0) {
             val inputBuffer = decoder.getInputBuffer(inputBufferIndex)!!
             val sampleSize = extractor.readSampleData(inputBuffer, 0)
@@ -485,8 +635,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
             }
           }
 
-          // Get PCM output from decoder and put to queue
-          val outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 10000)
+          // Get PCM output from decoder and put to queue (reduced timeout)
+          val outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 1000)
           if (outputBufferIndex >= 0) {
             val outputBuffer = decoder.getOutputBuffer(outputBufferIndex)!!
 
@@ -504,13 +654,13 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
                 pcmData = resamplePCM16(pcmData, sourceSampleRate, targetSampleRate, targetChannelCount)
               }
 
-              // Store for caching
-              decodedChunks.add(pcmData.clone())
+              // Optimization: avoid unnecessary clone() - store original for caching
+              decodedChunks.add(pcmData)
               totalBytes += pcmData.size
 
-              // Put to queue with sequence number
+              // Put a clone to queue (queue might modify it)
               val seqNum = sequenceStart.getAndIncrement()
-              queue.put(PCMChunk(pcmData, seqNum))
+              queue.put(PCMChunk(pcmData.clone(), seqNum))
             }
 
             decoder.releaseOutputBuffer(outputBufferIndex, false)
@@ -527,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) {
@@ -544,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)
@@ -582,16 +738,23 @@ 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
 
       while (!isEOS) {
-        // Feed input to decoder
-        val inputBufferIndex = decoder.dequeueInputBuffer(10000)
+        // Feed input to decoder (reduced timeout for faster processing)
+        val inputBufferIndex = decoder.dequeueInputBuffer(1000)
         if (inputBufferIndex >= 0) {
           val inputBuffer = decoder.getInputBuffer(inputBufferIndex)!!
           val sampleSize = extractor.readSampleData(inputBuffer, 0)
@@ -605,8 +768,8 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
           }
         }
 
-        // Get PCM output from decoder and feed to encoder
-        val outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 10000)
+        // Get PCM output from decoder and feed to encoder (reduced timeout)
+        val outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 1000)
         if (outputBufferIndex >= 0) {
           val outputBuffer = decoder.getOutputBuffer(outputBufferIndex)!!
 
@@ -637,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")
     }
   }
 
@@ -667,18 +835,32 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
 
     // For short silence (< 5 seconds), cache as single chunk
     if (durationMs < 5000) {
-      val silenceData = ByteArray(totalBytes) // All zeros = silence
+      // Use buffer pool to avoid allocation
+      val pooledBuffer = SilenceBufferPool.getBuffer(totalBytes)
+      val silenceData = if (pooledBuffer.size == totalBytes) {
+        pooledBuffer
+      } else {
+        // Copy only the needed portion
+        pooledBuffer.copyOf(totalBytes)
+      }
       cache.putSilence(cacheKey, silenceData)
       encoder.encodePCMChunk(silenceData, false)
     } else {
-      // For longer silence, process in chunks without caching
+      // For longer silence, process in chunks without caching using pooled buffers
       val chunkSamples = 16384
       var samplesRemaining = totalSamples
 
       while (samplesRemaining > 0) {
         val currentChunkSamples = minOf(chunkSamples, samplesRemaining)
         val chunkBytes = currentChunkSamples * bytesPerSample
-        val silenceChunk = ByteArray(chunkBytes)
+
+        // Use pooled buffer for chunk
+        val pooledBuffer = SilenceBufferPool.getBuffer(chunkBytes)
+        val silenceChunk = if (pooledBuffer.size == chunkBytes) {
+          pooledBuffer
+        } else {
+          pooledBuffer.copyOf(chunkBytes)
+        }
 
         encoder.encodePCMChunk(silenceChunk, false)
         samplesRemaining -= currentChunkSamples
@@ -686,6 +868,28 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
     }
   }
 
+  private fun getOptimalThreadCount(audioFileCount: Int): Int {
+    val cpuCores = Runtime.getRuntime().availableProcessors()
+    val optimalThreads = when {
+      cpuCores <= 2 -> 2
+      cpuCores <= 4 -> 3
+      cpuCores <= 8 -> 4
+      else -> 6
+    }
+    // Don't create more threads than files to process
+    return optimalThreads.coerceAtMost(audioFileCount)
+  }
+
+  private fun getOptimalQueueSize(audioFileCount: Int): Int {
+    // Dynamic queue size based on number of files to prevent memory waste or blocking
+    return when {
+      audioFileCount <= 5 -> 20
+      audioFileCount <= 20 -> 50
+      audioFileCount <= 50 -> 100
+      else -> 150
+    }
+  }
+
   private fun parallelProcessAudioFiles(
     audioFiles: List<Pair<Int, String>>, // (index, filePath)
     encoder: StreamingEncoder,
@@ -721,11 +925,17 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       i += count
     }
 
-    val pcmQueue = LinkedBlockingQueue<PCMChunk>(100)
+    val queueSize = getOptimalQueueSize(optimizedFiles.size)
+    val pcmQueue = LinkedBlockingQueue<PCMChunk>(queueSize)
+    Log.d("AudioConcat", "Using queue size: $queueSize for ${optimizedFiles.size} files")
     val executor = Executors.newFixedThreadPool(numThreads)
     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) ->
@@ -735,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
@@ -793,6 +1003,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
       Log.d("AudioConcat", "All parallel decode tasks completed")
 
     } finally {
+      decoderPool.releaseAll()
       executor.shutdown()
     }
   }
@@ -925,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) {
@@ -949,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)
@@ -963,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
@@ -989,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>()
@@ -1014,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
@@ -1091,13 +1321,15 @@ 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,
+                    outputSampleRate,
                     audioConfig.channelCount,
                     cache,
-                    numThreads = 3
+                    numThreads = optimalThreads
                   )
                   audioFileIdx = currentIdx
                 }
@@ -1109,7 +1341,7 @@ class AudioConcatModule(reactContext: ReactApplicationContext) :
                 streamEncodeSilence(
                   durationMs,
                   encoder,
-                  audioConfig.sampleRate,
+                  outputSampleRate,
                   audioConfig.channelCount,
                   cache
                 )
@@ -1117,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.4.0",
+  "version": "0.6.0",
   "description": "audio-concat for react-native",
   "main": "./lib/module/index.js",
   "types": "./lib/typescript/src/index.d.ts",