react-native-compressor 1.19.2 → 1.19.4

package/README.md

@@ -1,7 +1,7 @@
 <div align="center">
  <img height="150" src="/media/logo.png" />
 </div>
- 
+
 <br/>
 
 <div align="center">
@@ -14,6 +14,12 @@
 
 </div>
 
+> ⚠️ **Legacy Notice**
+>
+> This repository is now in **maintenance mode** for the v1 series. Version **1.19.3** will be the last release of v1. Development has moved to **[v2](https://github.com/numandev1/react-native-compressor)** which uses **Nitro Modules** for improved performance and maintainability.
+>
+> New features, bug fixes and enhancements will land in v2 only.
+
 **REACT-NATIVE-COMPRESSOR** is a react-native package, which helps us to Compress `Image`, `Video`, and `Audio` before uploading, same like **Whatsapp** without knowing the compression `algorithm`
 
 <div align="center">

package/android/build.gradle

@@ -119,7 +119,6 @@ dependencies {
   implementation "org.jetbrains.kotlinx:kotlinx-coroutines-android:1.6.4"
   implementation 'org.mp4parser:isoparser:1.9.56'
   implementation 'com.github.kaushik-naik:TAndroidLame:277c2ab4b0'
-  implementation 'javazoom:jlayer:1.0.1'
 }
 
 if (isNewArchitectureEnabled()) {

package/android/src/main/java/com/reactnativecompressor/Audio/AudioCompressor.kt

@@ -10,8 +10,6 @@ import com.naman14.androidlame.WaveReader
 import com.reactnativecompressor.Utils.MediaCache
 import com.reactnativecompressor.Utils.Utils
 import com.reactnativecompressor.Utils.Utils.addLog
-import javazoom.jl.converter.Converter
-import javazoom.jl.decoder.JavaLayerException
 import java.io.BufferedOutputStream
 import java.io.File
 import java.io.FileNotFoundException
@@ -20,11 +18,12 @@ import java.io.IOException
 
 class AudioCompressor {
   companion object {
-    val TAG="AudioMain"
+    val TAG = "AudioMain"
     private const val OUTPUT_STREAM_BUFFER = 8192
 
     var outputStream: BufferedOutputStream? = null
     var waveReader: WaveReader? = null
+
     @JvmStatic
     fun CompressAudio(
       fileUrl: String,
@@ -33,59 +32,76 @@ class AudioCompressor {
       promise: Promise,
     ) {
       val realPath = Utils.getRealPath(fileUrl, context)
-      var _fileUrl=realPath
+      var _fileUrl = realPath
       val filePathWithoutFileUri = realPath!!.replace("file://", "")
+
+      // These are declared outside the try block so they can be cleaned up
+      // in the catch handler. They must be nullable because the transcoding
+      // branch may not execute.
+      var wavPath: String? = null
+      var isNonWav: Boolean = false
+
       try {
-        var wavPath=filePathWithoutFileUri;
-        var isNonWav:Boolean=false
-        if (fileUrl.endsWith(".mp4", ignoreCase = true))
-        {
-          addLog("mp4 file found")
-          val mp3Path= Utils.generateCacheFilePath("mp3", context)
-          AudioExtractor().genVideoUsingMuxer(fileUrl, mp3Path, -1, -1, true, false)
-          _fileUrl=Utils.slashifyFilePath(mp3Path)
-          wavPath= Utils.generateCacheFilePath("wav", context)
+        wavPath = filePathWithoutFileUri
+        // LAME's WaveReader requires PCM 16-bit LE WAV. Anything else
+        // (m4a/AAC, mp3, ogg, flac, video audio tracks, ...) must be
+        // decoded to WAV first via the platform MediaCodec pipeline —
+        // jlayer's MP3-only Converter silently produced empty WAVs for
+        // every non-MP3 input, which LAME then encoded as a few seconds
+        // of silence (see #410 thread, m4a/AAC support).
+        //
+        // Check the resolved local path, not the original fileUrl: a
+        // content:// or remote URL won't carry the file extension, so
+        // checking fileUrl would mis-classify WAV inputs as non-WAV and
+        // route them through an unnecessary (and potentially failing)
+        // MediaCodec decode pass.
+        if (!filePathWithoutFileUri.endsWith(".wav", ignoreCase = true)) {
+          addLog("non wav file found, transcoding to PCM WAV")
+          wavPath = Utils.generateCacheFilePath("wav", context)
           try {
-            val converter = Converter()
-            converter.convert(mp3Path, wavPath)
-          } catch (e: JavaLayerException) {
-            addLog("JavaLayerException error"+e.localizedMessage)
-            e.printStackTrace();
+            AudioTranscoder.decodeToWav(filePathWithoutFileUri, wavPath)
+          } catch (e: IOException) {
+            addLog("AudioTranscoder failed: " + e.localizedMessage)
+            // Surface the failure rather than silently returning a
+            // degenerate MP3 of silence.
+            File(wavPath).delete()
+            promise.reject("audio_transcode_failed", e.localizedMessage ?: "Audio decode failed", e)
+            return
           }
-          isNonWav=true
-        }
-        else if (!fileUrl.endsWith(".wav", ignoreCase = true))
-        {
-          addLog("non wav file found")
-          wavPath= Utils.generateCacheFilePath("wav", context)
-          try {
-          val converter = Converter()
-          converter.convert(filePathWithoutFileUri, wavPath)
-        } catch (e: JavaLayerException) {
-          addLog("JavaLayerException error"+e.localizedMessage)
-          e.printStackTrace();
-        }
-          isNonWav=true
+          isNonWav = true
         }
 
-
-        autoCompressHelper(wavPath,filePathWithoutFileUri, optionMap,context) { mp3Path, finished ->
+        autoCompressHelper(wavPath, filePathWithoutFileUri, optionMap, context) { mp3Path, finished ->
           if (finished) {
-            val returnableFilePath:String="file://$mp3Path"
+            val returnableFilePath: String = "file://$mp3Path"
             addLog("finished: " + returnableFilePath)
             MediaCache.removeCompletedImagePath(fileUrl)
-            if(isNonWav)
-            {
+            if (isNonWav) {
               File(wavPath).delete()
             }
             promise.resolve(returnableFilePath)
           } else {
-            addLog("error: "+mp3Path)
+            addLog("error: " + mp3Path)
+            // Clean up the temp WAV on failure too; previously it was
+            // leaked because only the success path deleted it.
+            if (isNonWav) {
+              File(wavPath).delete()
+            }
             promise.resolve(_fileUrl)
           }
         }
       } catch (e: Exception) {
-        promise.resolve(_fileUrl)
+        addLog("CompressAudio failed: " + e.localizedMessage)
+        // Clean up any temp WAV that was created before the failure.
+        val temp = wavPath
+        if (isNonWav && temp != null) {
+          try {
+            File(temp).delete()
+          } catch (_: Throwable) {
+            // ignore cleanup failures
+          }
+        }
+        promise.reject("audio_compress_failed", e.localizedMessage ?: "Audio compression failed", e)
       }
     }
 
@@ -101,35 +117,34 @@ class AudioCompressor {
       val options = AudioHelper.fromMap(optionMap)
       val quality = options.quality
 
-      var isCompletedCallbackTriggered:Boolean=false
+      var isCompletedCallbackTriggered: Boolean = false
       try {
         var mp3Path = Utils.generateCacheFilePath("mp3", context)
         val input = File(fileUrl)
         val output = File(mp3Path)
 
         val CHUNK_SIZE = 8192
-      addLog("Initialising wav reader")
+        addLog("Initialising wav reader")
 
-      waveReader = WaveReader(input)
+        waveReader = WaveReader(input)
 
-      try {
-        waveReader!!.openWave()
-      } catch (e: IOException) {
-        e.printStackTrace()
-      }
+        try {
+          waveReader!!.openWave()
+        } catch (e: IOException) {
+          addLog("openWave failed: " + e.localizedMessage)
+          completeCallback(e.localizedMessage ?: "Failed to open WAV", false)
+          return
+        }
 
-      addLog("Intitialising encoder")
+        addLog("Intitialising encoder")
 
 
         // for bitrate
-        var audioBitrate:Int
-        if(options.bitrate != -1)
-        {
-          audioBitrate= options.bitrate/1000
-        }
-        else
-        {
-          audioBitrate=AudioHelper.getDestinationBitrateByQuality(actualFileUrl, quality!!)
+        var audioBitrate: Int
+        if (options.bitrate != -1) {
+          audioBitrate = options.bitrate / 1000
+        } else {
+          audioBitrate = AudioHelper.getDestinationBitrateByQuality(actualFileUrl, quality!!)
           Utils.addLog("dest bitrate: $audioBitrate")
         }
 
@@ -137,128 +152,126 @@ class AudioCompressor {
         androidLame.setOutBitrate(audioBitrate)
 
         // for channels
-        var audioChannels:Int
-        if(options.channels != -1){
-          audioChannels= options.channels!!
-        }
-        else
-        {
-          audioChannels=waveReader!!.channels
+        var audioChannels: Int
+        if (options.channels != -1) {
+          audioChannels = options.channels!!
+        } else {
+          audioChannels = waveReader!!.channels
         }
         androidLame.setOutChannels(audioChannels)
 
         // for sample rate
         androidLame.setInSampleRate(waveReader!!.sampleRate)
-        var audioSampleRate:Int
-        if(options.samplerate != -1){
-          audioSampleRate= options.samplerate!!
-        }
-        else
-        {
-          audioSampleRate=waveReader!!.sampleRate
+        var audioSampleRate: Int
+        if (options.samplerate != -1) {
+          audioSampleRate = options.samplerate!!
+        } else {
+          audioSampleRate = waveReader!!.sampleRate
         }
         androidLame.setOutSampleRate(audioSampleRate)
-        val androidLameBuild=androidLame.build()
+        val androidLameBuild = androidLame.build()
 
-      try {
-        outputStream = BufferedOutputStream(FileOutputStream(output), OUTPUT_STREAM_BUFFER)
-      } catch (e: FileNotFoundException) {
-        e.printStackTrace()
-      }
+        try {
+          outputStream = BufferedOutputStream(FileOutputStream(output), OUTPUT_STREAM_BUFFER)
+        } catch (e: FileNotFoundException) {
+          addLog("Failed to create output stream: " + e.localizedMessage)
+          completeCallback(e.localizedMessage ?: "Failed to create output file", false)
+          return
+        }
 
-      var bytesRead = 0
+        var bytesRead = 0
 
-      val buffer_l = ShortArray(CHUNK_SIZE)
-      val buffer_r = ShortArray(CHUNK_SIZE)
-      val mp3Buf = ByteArray(CHUNK_SIZE)
+        val buffer_l = ShortArray(CHUNK_SIZE)
+        val buffer_r = ShortArray(CHUNK_SIZE)
+        val mp3Buf = ByteArray(CHUNK_SIZE)
 
-      val channels = waveReader!!.channels
+        val channels = waveReader!!.channels
 
-      addLog("started encoding")
-      while (true) {
-        try {
-          if (channels == 2) {
+        addLog("started encoding")
+        while (true) {
+          try {
+            if (channels == 2) {
+
+              bytesRead = waveReader!!.read(buffer_l, buffer_r, CHUNK_SIZE)
+              addLog("bytes read=$bytesRead")
 
-            bytesRead = waveReader!!.read(buffer_l, buffer_r, CHUNK_SIZE)
-            addLog("bytes read=$bytesRead")
+              if (bytesRead > 0) {
 
-            if (bytesRead > 0) {
+                var bytesEncoded = 0
+                bytesEncoded = androidLameBuild.encode(buffer_l, buffer_r, bytesRead, mp3Buf)
+                addLog("bytes encoded=$bytesEncoded")
 
-              var bytesEncoded = 0
-              bytesEncoded = androidLameBuild.encode(buffer_l, buffer_r, bytesRead, mp3Buf)
-              addLog("bytes encoded=$bytesEncoded")
+                if (bytesEncoded > 0) {
+                  try {
+                    addLog("writing mp3 buffer to outputstream with $bytesEncoded bytes")
+                    outputStream!!.write(mp3Buf, 0, bytesEncoded)
+                  } catch (e: IOException) {
+                    e.printStackTrace()
+                  }
 
-              if (bytesEncoded > 0) {
-                try {
-                  addLog("writing mp3 buffer to outputstream with $bytesEncoded bytes")
-                  outputStream!!.write(mp3Buf, 0, bytesEncoded)
-                } catch (e: IOException) {
-                  e.printStackTrace()
                 }
 
-              }
+              } else
+                break
+            } else {
 
-            } else
-              break
-          } else {
+              bytesRead = waveReader!!.read(buffer_l, CHUNK_SIZE)
+              addLog("bytes read=$bytesRead")
 
-            bytesRead = waveReader!!.read(buffer_l, CHUNK_SIZE)
-            addLog("bytes read=$bytesRead")
+              if (bytesRead > 0) {
+                var bytesEncoded = 0
 
-            if (bytesRead > 0) {
-              var bytesEncoded = 0
+                bytesEncoded = androidLameBuild.encode(buffer_l, buffer_l, bytesRead, mp3Buf)
+                addLog("bytes encoded=$bytesEncoded")
 
-              bytesEncoded = androidLameBuild.encode(buffer_l, buffer_l, bytesRead, mp3Buf)
-              addLog("bytes encoded=$bytesEncoded")
+                if (bytesEncoded > 0) {
+                  try {
+                    addLog("writing mp3 buffer to outputstream with $bytesEncoded bytes")
+                    outputStream!!.write(mp3Buf, 0, bytesEncoded)
+                  } catch (e: IOException) {
+                    e.printStackTrace()
+                  }
 
-              if (bytesEncoded > 0) {
-                try {
-                  addLog("writing mp3 buffer to outputstream with $bytesEncoded bytes")
-                  outputStream!!.write(mp3Buf, 0, bytesEncoded)
-                } catch (e: IOException) {
-                  e.printStackTrace()
                 }
 
-              }
+              } else
+                break
+            }
 
-            } else
-              break
-          }
 
+          } catch (e: IOException) {
+            e.printStackTrace()
+          }
 
-        } catch (e: IOException) {
-          e.printStackTrace()
         }
 
-      }
-
-      addLog("flushing final mp3buffer")
-      val outputMp3buf = androidLameBuild.flush(mp3Buf)
-      addLog("flushed $outputMp3buf bytes")
-      if (outputMp3buf > 0) {
-        try {
-          addLog("writing final mp3buffer to outputstream")
-          outputStream!!.write(mp3Buf, 0, outputMp3buf)
-          addLog("closing output stream")
-          outputStream!!.close()
-          completeCallback(output.absolutePath, true)
-          isCompletedCallbackTriggered=true
-        } catch (e: IOException) {
-          completeCallback(e.localizedMessage, false)
-          e.printStackTrace()
+        addLog("flushing final mp3buffer")
+        val outputMp3buf = androidLameBuild.flush(mp3Buf)
+        addLog("flushed $outputMp3buf bytes")
+        if (outputMp3buf > 0) {
+          try {
+            addLog("writing final mp3buffer to outputstream")
+            outputStream!!.write(mp3Buf, 0, outputMp3buf)
+            addLog("closing output stream")
+            outputStream!!.close()
+            completeCallback(output.absolutePath, true)
+            isCompletedCallbackTriggered = true
+          } catch (e: IOException) {
+            completeCallback(e.localizedMessage, false)
+            isCompletedCallbackTriggered = true
+            e.printStackTrace()
+          }
         }
-      }
 
       } catch (e: IOException) {
         completeCallback(e.localizedMessage, false)
+        isCompletedCallbackTriggered = true
       }
-      if(!isCompletedCallbackTriggered)
-      {
+      if (!isCompletedCallbackTriggered) {
         completeCallback("something went wrong", false)
       }
     }
 
 
-
   }
 }

package/android/src/main/java/com/reactnativecompressor/Audio/AudioTranscoder.kt

@@ -0,0 +1,204 @@
+package com.reactnativecompressor.Audio
+
+import android.media.MediaCodec
+import android.media.MediaExtractor
+import android.media.MediaFormat
+import com.reactnativecompressor.Utils.Utils.addLog
+import java.io.BufferedOutputStream
+import java.io.File
+import java.io.FileOutputStream
+import java.io.IOException
+import java.io.RandomAccessFile
+import java.nio.ByteBuffer
+import java.nio.ByteOrder
+
+/**
+ * Decodes any audio container/codec Android can play (m4a/AAC, mp3, ogg,
+ * flac, ...) into a 16-bit PCM little-endian WAV file that LAME can consume.
+ *
+ * LAME's WaveReader only accepts PCM 16-bit LE WAV, so for any compressed
+ * (or non-matching) input we must transcode through a real decoder — jlayer's
+ * Converter is MP3-only and silently fails for m4a, ogg, flac, etc.
+ */
+internal object AudioTranscoder {
+
+  private const val TIMEOUT_US = 10_000L
+  private const val WAV_HEADER_SIZE = 44
+
+  /**
+   * Decode [srcPath] into a 16-bit PCM WAV at [dstPath].
+   *
+   * @throws IOException if the file cannot be opened, has no audio track,
+   *   cannot be decoded on this device, or the output cannot be written.
+   */
+  @Throws(IOException::class)
+  fun decodeToWav(srcPath: String, dstPath: String) {
+    addLog("decodeToWav: $srcPath -> $dstPath")
+
+    val extractor = MediaExtractor()
+    var decoder: MediaCodec? = null
+    var output: BufferedOutputStream? = null
+
+    try {
+      // -- setup extractor -------------------------------------------------
+      extractor.setDataSource(srcPath)
+
+      val audioTrackIndex = findAudioTrackIndex(extractor)
+        ?: throw IOException("No audio track found in $srcPath")
+      extractor.selectTrack(audioTrackIndex)
+
+      val inputFormat = extractor.getTrackFormat(audioTrackIndex)
+      val mime = inputFormat.getString(MediaFormat.KEY_MIME)
+        ?: throw IOException("Audio track has no mime in $srcPath")
+      val sampleRate = if (inputFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE)) {
+        inputFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE)
+      } else {
+        throw IOException("Audio track has no sample rate in $srcPath")
+      }
+      val channelCount = if (inputFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT)) {
+        inputFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT)
+      } else {
+        throw IOException("Audio track has no channel count in $srcPath")
+      }
+
+      // -- create + configure decoder ---------------------------------------
+      try {
+        decoder = MediaCodec.createDecoderByType(mime)
+      } catch (e: IllegalArgumentException) {
+        throw IOException("Device cannot decode audio mime $mime", e)
+      } catch (e: Exception) {
+        throw IOException("Failed to create decoder for $mime", e)
+      }
+      decoder!!.configure(inputFormat, null, null, 0)
+      decoder!!.start()
+
+      // Capture a non-null val so Kotlin smart-cast works in the loop below.
+      val d = decoder!!
+
+      // -- prepare output WAV file ------------------------------------------
+      val outFile = File(dstPath)
+      outFile.parentFile?.mkdirs()
+      output = BufferedOutputStream(FileOutputStream(outFile))
+      // Reserve 44 bytes for the RIFF/WAVE header; we'll come back and
+      // overwrite with the correct sizes once we know how many PCM bytes
+      // were produced.
+      output.write(ByteArray(WAV_HEADER_SIZE))
+
+      var totalBytesWritten = 0L
+      val info = MediaCodec.BufferInfo()
+      var inputDone = false
+      var outputDone = false
+
+      // -- decode loop ------------------------------------------------------
+      while (!outputDone) {
+        // Feed compressed samples into the decoder.
+        if (!inputDone) {
+          val inIndex = d.dequeueInputBuffer(TIMEOUT_US)
+          if (inIndex >= 0) {
+            val inBuf = d.getInputBuffer(inIndex)
+              ?: throw IOException("Decoder returned null input buffer")
+            inBuf.clear()
+            val sampleSize = extractor.readSampleData(inBuf, 0)
+            if (sampleSize < 0) {
+              d.queueInputBuffer(
+                inIndex, 0, 0, 0,
+                MediaCodec.BUFFER_FLAG_END_OF_STREAM
+              )
+              inputDone = true
+            } else {
+              d.queueInputBuffer(
+                inIndex, 0, sampleSize, extractor.sampleTime, 0
+              )
+              extractor.advance()
+            }
+          }
+        }
+
+        // Drain decoded PCM and append it to the file (after the header
+        // placeholder).
+        val outIndex = d.dequeueOutputBuffer(info, TIMEOUT_US)
+        if (outIndex >= 0) {
+          val outBuf = d.getOutputBuffer(outIndex)
+            ?: throw IOException("Decoder returned null output buffer")
+          if (info.size > 0) {
+            // outBuf is a direct ByteBuffer; data is laid out in native byte
+            // order in [info.offset, info.offset + info.size). Copy the whole
+            // run in a single contiguous read.
+            val copy = ByteArray(info.size)
+            outBuf.position(info.offset)
+            outBuf.get(copy)
+            output.write(copy)
+            totalBytesWritten += info.size
+          }
+          d.releaseOutputBuffer(outIndex, false)
+
+          if (info.flags and MediaCodec.BUFFER_FLAG_END_OF_STREAM != 0) {
+            outputDone = true
+          }
+        } else if (outIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
+          // The final decoded format may differ from what we read at
+          // configure time (e.g. AAC decoder may change channel layout
+          // after the first frame). Log it for diagnostics; the header we
+          // write at the end will use the configure-time values, which is
+          // the standard PCM layout that LAME expects.
+          addLog("decoder output format changed: ${d.outputFormat}")
+        }
+      }
+
+      output.flush()
+
+      // Patch the WAV header with the final sizes now that we know them.
+      writeWavHeader(outFile, sampleRate, channelCount, totalBytesWritten)
+
+      addLog("decodeToWav: wrote $totalBytesWritten PCM bytes")
+    } finally {
+      runCatching { decoder?.stop() }
+      runCatching { decoder?.release() }
+      runCatching { extractor.release() }
+      runCatching { output?.close() }
+    }
+  }
+
+  private fun findAudioTrackIndex(extractor: MediaExtractor): Int? {
+    for (i in 0 until extractor.trackCount) {
+      val mime = extractor.getTrackFormat(i).getString(MediaFormat.KEY_MIME)
+      if (mime != null && mime.startsWith("audio/")) return i
+    }
+    return null
+  }
+
+  /**
+   * Write a standard 44-byte PCM 16-bit little-endian WAV header into the
+   * first [WAV_HEADER_SIZE] bytes of [outFile], anchored to the [dataBytes]
+   * sample body that follows.
+   */
+  private fun writeWavHeader(outFile: File, sampleRate: Int, channels: Int, dataBytes: Long) {
+    val header = ByteBuffer.allocate(WAV_HEADER_SIZE).order(ByteOrder.LITTLE_ENDIAN)
+    val byteRate = sampleRate * channels * 2 // 16-bit = 2 bytes per sample
+    val blockAlign = (channels * 2).toShort()
+    val chunkSize = 36L + dataBytes
+
+    header.put("RIFF".toByteArray(Charsets.US_ASCII))
+    header.putInt(chunkSize.toInt())
+    header.put("WAVE".toByteArray(Charsets.US_ASCII))
+    header.put("fmt ".toByteArray(Charsets.US_ASCII))
+    header.putInt(16) // PCM fmt chunk size
+    header.putShort(1) // PCM format
+    header.putShort(channels.toShort())
+    header.putInt(sampleRate)
+    header.putInt(byteRate)
+    header.putShort(blockAlign)
+    header.putShort(16) // bits per sample
+    header.put("data".toByteArray(Charsets.US_ASCII))
+    header.putInt(dataBytes.toInt())
+
+    val raf = RandomAccessFile(outFile, "rw")
+    try {
+      raf.seek(0)
+      raf.write(header.array(), 0, WAV_HEADER_SIZE)
+    } finally {
+      raf.close()
+    }
+  }
+
+}