react-native-audio-concat 0.2.0

package/AudioConcat.podspec

@@ -0,0 +1,30 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "AudioConcat"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/felixchen-dev/react-native-audio-concat.git", :tag => "#{s.version}" }
+
+
+  s.source_files = [
+    "ios/**/*.{swift}",
+    "ios/**/*.{m,mm}",
+    "cpp/**/*.{hpp,cpp}",
+  ]
+
+  s.dependency 'React-jsi'
+  s.dependency 'React-callinvoker'
+
+  load 'nitrogen/generated/ios/AudioConcat+autolinking.rb'
+  add_nitrogen_files(s)
+
+  install_modules_dependencies(s)
+end

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2025 Meng Chan
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,39 @@
+# react-native-audio-concat
+
+audio-concat for react-native
+
+## Installation
+
+
+```sh
+npm install react-native-audio-concat react-native-nitro-modules
+
+> `react-native-nitro-modules` is required as this library relies on [Nitro Modules](https://nitro.margelo.com/).
+```
+
+
+## Usage
+
+
+```js
+import { multiply } from 'react-native-audio-concat';
+
+// ...
+
+const result = multiply(3, 7);
+```
+
+
+## Contributing
+
+- [Development workflow](CONTRIBUTING.md#development-workflow)
+- [Sending a pull request](CONTRIBUTING.md#sending-a-pull-request)
+- [Code of conduct](CODE_OF_CONDUCT.md)
+
+## License
+
+MIT
+
+---
+
+Made with [create-react-native-library](https://github.com/callstack/react-native-builder-bob)

package/android/CMakeLists.txt

@@ -0,0 +1,24 @@
+project(audioconcat)
+cmake_minimum_required(VERSION 3.9.0)
+
+set(PACKAGE_NAME audioconcat)
+set(CMAKE_VERBOSE_MAKEFILE ON)
+set(CMAKE_CXX_STANDARD 20)
+
+# Define C++ library and add all sources
+add_library(${PACKAGE_NAME} SHARED src/main/cpp/cpp-adapter.cpp)
+
+# Add Nitrogen specs :)
+include(${CMAKE_SOURCE_DIR}/../nitrogen/generated/android/audioconcat+autolinking.cmake)
+
+# Set up local includes
+include_directories("src/main/cpp" "../cpp")
+
+find_library(LOG_LIB log)
+
+# Link all libraries together
+target_link_libraries(
+        ${PACKAGE_NAME}
+        ${LOG_LIB}
+        android # <-- Android core
+)

package/android/build.gradle

@@ -0,0 +1,128 @@
+buildscript {
+  ext.getExtOrDefault = {name ->
+    return rootProject.ext.has(name) ? rootProject.ext.get(name) : project.properties['AudioConcat_' + name]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+def reactNativeArchitectures() {
+  def value = rootProject.getProperties().get("reactNativeArchitectures")
+  return value ? value.split(",") : ["armeabi-v7a", "x86", "x86_64", "arm64-v8a"]
+}
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+apply from: '../nitrogen/generated/android/audioconcat+autolinking.gradle'
+
+apply plugin: "com.facebook.react"
+
+def getExtOrIntegerDefault(name) {
+  return rootProject.ext.has(name) ? rootProject.ext.get(name) : (project.properties["AudioConcat_" + name]).toInteger()
+}
+
+android {
+  namespace "com.margelo.nitro.audioconcat"
+
+  compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrIntegerDefault("minSdkVersion")
+    targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
+
+    externalNativeBuild {
+      cmake {
+        cppFlags "-frtti -fexceptions -Wall -fstack-protector-all"
+        arguments "-DANDROID_STL=c++_shared", "-DANDROID_SUPPORT_FLEXIBLE_PAGE_SIZES=ON"
+        abiFilters (*reactNativeArchitectures())
+
+        buildTypes {
+          debug {
+            cppFlags "-O1 -g"
+          }
+          release {
+            cppFlags "-O2"
+          }
+        }
+      }
+    }
+  }
+
+  externalNativeBuild {
+    cmake {
+      path "CMakeLists.txt"
+    }
+  }
+
+  packagingOptions {
+    excludes = [
+            "META-INF",
+            "META-INF/**",
+            "**/libc++_shared.so",
+            "**/libfbjni.so",
+            "**/libjsi.so",
+            "**/libfolly_json.so",
+            "**/libfolly_runtime.so",
+            "**/libglog.so",
+            "**/libhermes.so",
+            "**/libhermes-executor-debug.so",
+            "**/libhermes_executor.so",
+            "**/libreactnative.so",
+            "**/libreactnativejni.so",
+            "**/libturbomodulejsijni.so",
+            "**/libreact_nativemodule_core.so",
+            "**/libjscexecutor.so"
+    ]
+  }
+
+  buildFeatures {
+    buildConfig true
+    prefab true
+  }
+
+  buildTypes {
+    release {
+      minifyEnabled false
+    }
+  }
+
+  lintOptions {
+    disable "GradleCompatible"
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_1_8
+    targetCompatibility JavaVersion.VERSION_1_8
+  }
+
+  sourceSets {
+    main {
+      java.srcDirs += [
+        "generated/java",
+        "generated/jni"
+      ]
+    }
+  }
+}
+
+repositories {
+  mavenCentral()
+  google()
+}
+
+def kotlin_version = getExtOrDefault("kotlinVersion")
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+  implementation project(":react-native-nitro-modules")
+}

package/android/gradle.properties

@@ -0,0 +1,5 @@
+AudioConcat_kotlinVersion=2.0.21
+AudioConcat_minSdkVersion=24
+AudioConcat_targetSdkVersion=34
+AudioConcat_compileSdkVersion=35
+AudioConcat_ndkVersion=27.1.12297006

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,2 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+</manifest>

package/android/src/main/cpp/cpp-adapter.cpp

@@ -0,0 +1,6 @@
+#include <jni.h>
+#include "audioconcatOnLoad.hpp"
+
+JNIEXPORT jint JNICALL JNI_OnLoad(JavaVM* vm, void*) {
+  return margelo::nitro::audioconcat::initialize(vm);
+}

package/android/src/main/java/com/margelo/nitro/audioconcat/AudioConcat.kt

@@ -0,0 +1,349 @@
+package com.margelo.nitro.audioconcat
+  
+import com.facebook.proguard.annotations.DoNotStrip
+import com.margelo.nitro.core.Promise
+import android.media.MediaCodec
+import android.media.MediaCodecInfo
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import android.media.MediaMuxer
+import java.io.File
+import java.nio.ByteBuffer
+import android.util.Log
+
+@DoNotStrip
+class AudioConcat : HybridAudioConcatSpec() {
+private data class AudioConfig(
+    val sampleRate: Int,
+    val channelCount: Int,
+    val bitRate: Int
+  )
+
+  private fun extractAudioConfig(filePath: String): AudioConfig {
+    val extractor = MediaExtractor()
+    try {
+      extractor.setDataSource(filePath)
+      for (i in 0 until extractor.trackCount) {
+        val format = extractor.getTrackFormat(i)
+        val mime = format.getString(MediaFormat.KEY_MIME) ?: continue
+        if (mime.startsWith("audio/")) {
+          val sampleRate = format.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+          val channelCount = format.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+          val bitRate = if (format.containsKey(MediaFormat.KEY_BIT_RATE)) {
+            format.getInteger(MediaFormat.KEY_BIT_RATE)
+          } else {
+            128000 // Default 128kbps
+          }
+          return AudioConfig(sampleRate, channelCount, bitRate)
+        }
+      }
+      throw Exception("No audio track found in $filePath")
+    } finally {
+      extractor.release()
+    }
+  }
+
+  private class StreamingEncoder(
+    sampleRate: Int,
+    channelCount: Int,
+    bitRate: Int,
+    outputPath: String
+  ) {
+    private val encoder: MediaCodec
+    private val muxer: MediaMuxer
+    private var audioTrackIndex = -1
+    private var muxerStarted = false
+    private val bufferInfo = MediaCodec.BufferInfo()
+    private var totalPresentationTimeUs = 0L
+    private val sampleRate: Int
+    private val channelCount: Int
+
+    init {
+      this.sampleRate = sampleRate
+      this.channelCount = channelCount
+
+      val outputFormat = MediaFormat.createAudioFormat(
+        MediaFormat.MIMETYPE_AUDIO_AAC,
+        sampleRate,
+        channelCount
+      )
+      outputFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC)
+      outputFormat.setInteger(MediaFormat.KEY_BIT_RATE, bitRate)
+      outputFormat.setInteger(MediaFormat.KEY_MAX_INPUT_SIZE, 16384)
+
+      encoder = MediaCodec.createEncoderByType(MediaFormat.MIMETYPE_AUDIO_AAC)
+      encoder.configure(outputFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE)
+      encoder.start()
+
+      muxer = MediaMuxer(outputPath, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4)
+    }
+
+    fun encodePCMChunk(pcmData: ByteArray, isLast: Boolean = false): Boolean {
+      // Feed PCM data to encoder
+      val inputBufferIndex = encoder.dequeueInputBuffer(10000)
+      if (inputBufferIndex >= 0) {
+        val inputBuffer = encoder.getInputBuffer(inputBufferIndex)!!
+        inputBuffer.clear()
+        inputBuffer.put(pcmData)
+
+        val presentationTimeUs = totalPresentationTimeUs
+        totalPresentationTimeUs += (pcmData.size.toLong() * 1_000_000) / (sampleRate * channelCount * 2)
+
+        val flags = if (isLast) MediaCodec.BUFFER_FLAG_END_OF_STREAM else 0
+        encoder.queueInputBuffer(inputBufferIndex, 0, pcmData.size, presentationTimeUs, flags)
+      }
+
+      // Drain encoder output
+      drainEncoder(isLast)
+
+      return true
+    }
+
+    private fun drainEncoder(endOfStream: Boolean) {
+      while (true) {
+        val outputBufferIndex = encoder.dequeueOutputBuffer(bufferInfo, if (endOfStream) 10000 else 0)
+
+        when (outputBufferIndex) {
+          MediaCodec.INFO_OUTPUT_FORMAT_CHANGED -> {
+            if (muxerStarted) {
+              throw RuntimeException("Format changed twice")
+            }
+            val newFormat = encoder.outputFormat
+            audioTrackIndex = muxer.addTrack(newFormat)
+            muxer.start()
+            muxerStarted = true
+            Log.d("AwesomeLibrary", "Encoder started, format: $newFormat")
+          }
+          MediaCodec.INFO_TRY_AGAIN_LATER -> {
+            if (!endOfStream) {
+              break
+            }
+            // Continue draining when end of stream
+          }
+          else -> {
+            if (outputBufferIndex >= 0) {
+              val outputBuffer = encoder.getOutputBuffer(outputBufferIndex)!!
+
+              if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
+                bufferInfo.size = 0
+              }
+
+              if (bufferInfo.size > 0 && muxerStarted) {
+                outputBuffer.position(bufferInfo.offset)
+                outputBuffer.limit(bufferInfo.offset + bufferInfo.size)
+                muxer.writeSampleData(audioTrackIndex, outputBuffer, bufferInfo)
+              }
+
+              encoder.releaseOutputBuffer(outputBufferIndex, false)
+
+              if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                break
+              }
+            }
+          }
+        }
+      }
+    }
+
+    fun finish() {
+      // Signal end of stream
+      val inputBufferIndex = encoder.dequeueInputBuffer(10000)
+      if (inputBufferIndex >= 0) {
+        encoder.queueInputBuffer(inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM)
+      }
+
+      // Drain remaining data
+      drainEncoder(true)
+
+      encoder.stop()
+      encoder.release()
+
+      if (muxerStarted) {
+        muxer.stop()
+      }
+      muxer.release()
+    }
+  }
+
+  private fun streamDecodeAudioFile(
+    filePath: String,
+    encoder: StreamingEncoder,
+    isLastFile: Boolean
+  ) {
+    val extractor = MediaExtractor()
+    var decoder: MediaCodec? = null
+
+    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")
+      }
+
+      extractor.selectTrack(audioTrackIndex)
+
+      val mime = audioFormat.getString(MediaFormat.KEY_MIME)!!
+      decoder = MediaCodec.createDecoderByType(mime)
+      decoder.configure(audioFormat, null, null, 0)
+      decoder.start()
+
+      val bufferInfo = MediaCodec.BufferInfo()
+      var isEOS = false
+      val pcmChunkSize = 8192 // Process in 8KB chunks
+
+      while (!isEOS) {
+        // Feed input to decoder
+        val inputBufferIndex = decoder.dequeueInputBuffer(10000)
+        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 PCM output from decoder and feed to encoder
+        val outputBufferIndex = decoder.dequeueOutputBuffer(bufferInfo, 10000)
+        if (outputBufferIndex >= 0) {
+          val outputBuffer = decoder.getOutputBuffer(outputBufferIndex)!!
+
+          if (bufferInfo.size > 0) {
+            val pcmData = ByteArray(bufferInfo.size)
+            outputBuffer.get(pcmData)
+
+            // Stream to encoder immediately
+            encoder.encodePCMChunk(pcmData, false)
+          }
+
+          decoder.releaseOutputBuffer(outputBufferIndex, false)
+
+          if ((bufferInfo.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+            isEOS = true
+          }
+        }
+      }
+
+    } finally {
+      decoder?.stop()
+      decoder?.release()
+      extractor.release()
+    }
+  }
+
+  private fun streamEncodeSilence(
+    durationMs: Double,
+    encoder: StreamingEncoder,
+    sampleRate: Int,
+    channelCount: Int
+  ) {
+    val totalSamples = ((durationMs / 1000.0) * sampleRate).toInt()
+    val chunkSamples = 4096 // Process in chunks
+    val bytesPerSample = channelCount * 2 // 16-bit stereo
+
+    var samplesRemaining = totalSamples
+
+    while (samplesRemaining > 0) {
+      val currentChunkSamples = minOf(chunkSamples, samplesRemaining)
+      val chunkBytes = currentChunkSamples * bytesPerSample
+      val silenceChunk = ByteArray(chunkBytes) // All zeros = silence
+
+      encoder.encodePCMChunk(silenceChunk, false)
+      samplesRemaining -= currentChunkSamples
+    }
+  }
+
+  override fun concatAudioFiles(data: Array<AudioDataOrSilence>, outputPath: String): Promise<String> {
+    return Promise.async {
+      if (data.isEmpty()) {
+        throw Exception("Data array is empty")
+      }
+
+      Log.d("AwesomeLibrary", "Streaming merge of ${data.size} items")
+      Log.d("AwesomeLibrary", "Output: $outputPath")
+
+      // Get audio config from first audio file
+      var audioConfig: AudioConfig? = null
+      for (item in data) {
+        if (item is AudioDataOrSilence.First) {
+          audioConfig = extractAudioConfig(item.value.filePath)
+          break
+        }
+      }
+
+      if (audioConfig == null) {
+        throw Exception("No audio files found in data array")
+      }
+
+      Log.d("AwesomeLibrary", "Audio config: ${audioConfig.sampleRate}Hz, ${audioConfig.channelCount}ch, ${audioConfig.bitRate}bps")
+
+      // Delete existing output file
+      val outputFile = File(outputPath)
+      if (outputFile.exists()) {
+        outputFile.delete()
+      }
+
+      // Create streaming encoder
+      val encoder = StreamingEncoder(
+        audioConfig.sampleRate,
+        audioConfig.channelCount,
+        audioConfig.bitRate,
+        outputPath
+      )
+
+      try {
+        // Process each item
+        for ((index, item) in data.withIndex()) {
+          when (item) {
+            is AudioDataOrSilence.First -> {
+              val filePath = item.value.filePath
+              Log.d("AwesomeLibrary", "Item $index: Streaming decode $filePath")
+
+              val isLastFile = (index == data.size - 1)
+              streamDecodeAudioFile(filePath, encoder, isLastFile)
+            }
+
+            is AudioDataOrSilence.Second -> {
+              val durationMs = item.value.durationMs
+              Log.d("AwesomeLibrary", "Item $index: Streaming silence ${durationMs}ms")
+
+              streamEncodeSilence(
+                durationMs,
+                encoder,
+                audioConfig.sampleRate,
+                audioConfig.channelCount
+              )
+            }
+          }
+        }
+
+        // Finish encoding
+        encoder.finish()
+        Log.d("AwesomeLibrary", "Successfully merged audio to $outputPath")
+
+      } catch (e: Exception) {
+        Log.e("AwesomeLibrary", "Error during streaming merge: ${e.message}", e)
+        throw e
+      }
+
+      outputPath
+    }
+  }
+}

package/android/src/main/java/com/margelo/nitro/audioconcat/AudioConcatPackage.kt

@@ -0,0 +1,22 @@
+package com.margelo.nitro.audioconcat
+
+import com.facebook.react.TurboReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfoProvider
+
+class AudioConcatPackage : TurboReactPackage() {
+    override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+        return null
+    }
+
+    override fun getReactModuleInfoProvider(): ReactModuleInfoProvider {
+        return ReactModuleInfoProvider { HashMap() }
+    }
+
+    companion object {
+        init {
+            System.loadLibrary("audioconcat")
+        }
+    }
+}