react-native-compressor 1.8.15 → 1.8.17

package/README.md

@@ -129,9 +129,9 @@ react-native link react-native-compressor
 
 #### iOS
 
-1. In XCode, in the project navigator, right click `Libraries` ➜ `Add Files to [your project's name]`
-2. Go to `node_modules` ➜ `react-native-compressor` and add `Compressor.xcodeproj`
-3. In XCode, in the project navigator, select your project. Add `libCompressor.a` to your project's `Build Phases` ➜ `Link Binary With Libraries`
+1. In XCode, open Podfile
+2. paste this line `pod 'react-native-compressor', :path => '../node_modules/react-native-compressor'` into `Podfile`
+3. run this command inside ios folder `pod install`
 4. Run your project (`Cmd+R`)<
 
 #### Android
@@ -270,6 +270,17 @@ const result = await Audio.compress(
   'file://path_of_file/file_example_MP3_2MG.wav', // recommended wav file but can be use mp3 file
   { quality: 'medium' }
 );
+
+// OR
+
+const result = await Audio.compress(
+  'file://path_of_file/file_example_MP3_2MG.wav', // recommended wav file but can be use mp3 file
+  {
+    bitrate: 64000,
+    samplerate: 44100,
+    channels: 1,
+  }
+);
 ```
 
 ### Background Upload
@@ -377,8 +388,14 @@ await clearCache(); // this will clear cache of thumbnails cache directory
 - ###### `compress(url: string, options?: videoCompresssionType , onProgress?: (progress: number)): Promise<string>`
 
 - ###### `cancelCompression(cancellationId: string): void`
+
   we can get cancellationId from `getCancellationId` which is the callback method of compress method options
 
+- ###### `activateBackgroundTask(onExpired?: (data: any) => void): Promise<any>`
+  if you wanna compress video while app is in backgroup then you should call this method before compression
+- ###### `deactivateBackgroundTask(): Promise<any>`
+  if you call `activateBackgroundTask` method, then after video compression, you should call `deactivateBackgroundTask` for disable background task mode.
+
 ### videoCompresssionType
 
 - ###### `compressionMethod: compressionMethod` (default: "manual")
@@ -415,10 +432,20 @@ await clearCache(); // this will clear cache of thumbnails cache directory
 
 ### audioCompresssionType
 
-- ###### `quality: qualityType` (default: medium)
+- ###### `quality?: qualityType` (default: medium)
+
   we can also control bitrate through quality. qualityType can be `low` | `medium` | `high`
 
-**Note: manual bitrate, samplerate etc will add soon**
+- ###### `bitrate?: number` Range [64000-320000]
+
+  we can control bitrate of audio through bitrate, it should be in the range of `64000-320000`
+
+- ###### `samplerate?: number` Range [44100 - 192000]
+
+  we can control samplerate of audio through samplerate, it should be in the range of `44100 - 192000`
+
+- ###### `channels?: number` Typically 1 or 2
+  we can control channels of audio through channels, Typically 1 or 2
 
 ## Background Upload
 
@@ -492,11 +519,11 @@ const metaData = await getVideoMetaData(filePath);
 
 ```
 {
-	"duration": "6",
+	"duration": 20.11,
 	"extension": "mp4",
-	"height": "1080",
-	"size": "16940.0",
-	"width": "1920"
+	"height": 1080,
+	"size": 16940.0,
+	"width": 1920
 }
 ```
 

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

@@ -4,6 +4,7 @@ package com.reactnativecompressor.Audio
 import android.annotation.SuppressLint
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.ReadableMap
 import com.naman14.androidlame.LameBuilder
 import com.naman14.androidlame.WaveReader
 import com.reactnativecompressor.Utils.MediaCache
@@ -27,21 +28,22 @@ class AudioCompressor {
     @JvmStatic
     fun CompressAudio(
       fileUrl: String,
-      quality: String,
+      optionMap: ReadableMap,
       context: ReactApplicationContext,
       promise: Promise,
     ) {
-      var _fileUrl=fileUrl
+      val realPath = Utils.getRealPath(fileUrl, context)
+      var _fileUrl=realPath
+      val filePathWithoutFileUri = realPath!!.replace("file://", "")
       try {
-        val filePath = fileUrl.replace("file://", "")
-        var wavPath=filePath;
+        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="file:/"+mp3Path
+          _fileUrl=Utils.slashifyFilePath(mp3Path)
           wavPath= Utils.generateCacheFilePath("wav", context)
           try {
             val converter = Converter()
@@ -58,7 +60,7 @@ class AudioCompressor {
           wavPath= Utils.generateCacheFilePath("wav", context)
           try {
           val converter = Converter()
-          converter.convert(filePath, wavPath)
+          converter.convert(filePathWithoutFileUri, wavPath)
         } catch (e: JavaLayerException) {
           addLog("JavaLayerException error"+e.localizedMessage)
           e.printStackTrace();
@@ -67,7 +69,7 @@ class AudioCompressor {
         }
 
 
-        autoCompressHelper(wavPath, quality,context) { mp3Path, finished ->
+        autoCompressHelper(wavPath,filePathWithoutFileUri, optionMap,context) { mp3Path, finished ->
           if (finished) {
             val returnableFilePath:String="file://$mp3Path"
             addLog("finished: " + returnableFilePath)
@@ -87,28 +89,23 @@ class AudioCompressor {
       }
     }
 
-    private fun getAudioBitrateByQuality(quality: String): Int {
-      return when (quality) {
-        "low" -> 64 // Set your low bitrate value here
-        "medium" -> 128 // Set your medium bitrate value here
-        "high" -> 256 // Set your high bitrate value here
-        else -> 128 // Default to medium bitrate if quality is not recognized
-      }
-    }
-
     @SuppressLint("WrongConstant")
     private fun autoCompressHelper(
       fileUrl: String,
-      quality: String,
+      actualFileUrl: String,
+      optionMap: ReadableMap,
       context: ReactApplicationContext,
       completeCallback: (String, Boolean) -> Unit
     ) {
+
+      val options = AudioHelper.fromMap(optionMap)
+      val quality = options.quality
+
       var isCompletedCallbackTriggered:Boolean=false
       try {
         var mp3Path = Utils.generateCacheFilePath("mp3", context)
         val input = File(fileUrl)
         val output = File(mp3Path)
-        val audioBitrate= getAudioBitrateByQuality(quality)
 
         val CHUNK_SIZE = 8192
       addLog("Initialising wav reader")
@@ -122,12 +119,46 @@ class AudioCompressor {
       }
 
       addLog("Intitialising encoder")
-      val androidLame = LameBuilder()
-        .setInSampleRate(waveReader!!.sampleRate)
-        .setOutChannels(waveReader!!.channels)
-        .setOutBitrate(audioBitrate)
-        .setOutSampleRate(waveReader!!.sampleRate)
-        .build()
+
+
+        // for bitrate
+        var audioBitrate:Int
+        if(options.bitrate != -1)
+        {
+          audioBitrate= options.bitrate/1000
+        }
+        else
+        {
+          audioBitrate=AudioHelper.getDestinationBitrateByQuality(actualFileUrl, quality!!)
+          Utils.addLog("dest bitrate: $audioBitrate")
+        }
+
+        var androidLame = LameBuilder();
+        androidLame.setOutBitrate(audioBitrate)
+
+        // for 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
+        }
+        androidLame.setOutSampleRate(audioSampleRate)
+        val androidLameBuild=androidLame.build()
 
       try {
         outputStream = BufferedOutputStream(FileOutputStream(output), OUTPUT_STREAM_BUFFER)
@@ -154,7 +185,7 @@ class AudioCompressor {
             if (bytesRead > 0) {
 
               var bytesEncoded = 0
-              bytesEncoded = androidLame.encode(buffer_l, buffer_r, bytesRead, mp3Buf)
+              bytesEncoded = androidLameBuild.encode(buffer_l, buffer_r, bytesRead, mp3Buf)
               addLog("bytes encoded=$bytesEncoded")
 
               if (bytesEncoded > 0) {
@@ -177,7 +208,7 @@ class AudioCompressor {
             if (bytesRead > 0) {
               var bytesEncoded = 0
 
-              bytesEncoded = androidLame.encode(buffer_l, buffer_l, bytesRead, mp3Buf)
+              bytesEncoded = androidLameBuild.encode(buffer_l, buffer_l, bytesRead, mp3Buf)
               addLog("bytes encoded=$bytesEncoded")
 
               if (bytesEncoded > 0) {
@@ -202,7 +233,7 @@ class AudioCompressor {
       }
 
       addLog("flushing final mp3buffer")
-      val outputMp3buf = androidLame.flush(mp3Buf)
+      val outputMp3buf = androidLameBuild.flush(mp3Buf)
       addLog("flushed $outputMp3buf bytes")
       if (outputMp3buf > 0) {
         try {

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

@@ -1,10 +1,19 @@
 package com.reactnativecompressor.Audio
 
+import android.media.MediaExtractor
+import android.media.MediaFormat
 import com.facebook.react.bridge.ReadableMap
+import com.reactnativecompressor.Utils.Utils
+import java.io.File
+import java.io.IOException
+
 
 class AudioHelper {
 
   var quality: String? = "medium"
+  var bitrate: Int = -1
+  var samplerate: Int = -1
+  var channels: Int = -1
   var progressDivider: Int? = 0
 
   companion object {
@@ -15,9 +24,49 @@ class AudioHelper {
         val key = iterator.nextKey()
         when (key) {
           "quality" -> options.quality = map.getString(key)
+          "bitrate" -> {
+            val bitrate = map.getInt(key)
+            options.bitrate = if (bitrate > 320000 || bitrate < 64000) 64000 else bitrate
+          }
+          "samplerate" -> options.samplerate = map.getInt(key)
+          "channels" -> options.channels = map.getInt(key)
         }
       }
       return options
     }
+
+
+    fun getAudioBitrate(path: String): Int {
+      val file = File(path)
+      val fileSize = file.length() * 8 // size in bits
+
+      val mex = MediaExtractor()
+      try {
+        mex.setDataSource(path)
+      } catch (e: IOException) {
+        e.printStackTrace()
+      }
+
+      val mf = mex.getTrackFormat(0)
+      val durationUs = mf.getLong(MediaFormat.KEY_DURATION)
+      val durationSec = durationUs / 1_000_000.0 // convert duration to seconds
+
+      return (fileSize / durationSec).toInt()/1000 // bitrate in bits per second
+    }
+    fun getDestinationBitrateByQuality(path: String, quality: String): Int {
+      val originalBitrate = getAudioBitrate(path)
+      var destinationBitrate = originalBitrate
+      Utils.addLog("source bitrate: $originalBitrate")
+
+      when (quality.toLowerCase()) {
+        "low" -> destinationBitrate = maxOf(64, (originalBitrate * 0.3).toInt())
+        "medium" -> destinationBitrate = (originalBitrate * 0.5).toInt()
+        "high" -> destinationBitrate = minOf(320, (originalBitrate * 0.7).toInt())
+        else -> Utils.addLog("Invalid quality level. Please enter 'low', 'medium', or 'high'.")
+      }
+
+      return destinationBitrate
+    }
+
   }
 }

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

@@ -3,7 +3,6 @@ package com.reactnativecompressor.Audio
 import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
-import com.reactnativecompressor.Utils.Utils
 
 class AudioMain(private val reactContext: ReactApplicationContext) {
   fun compress_audio(
@@ -11,11 +10,8 @@ class AudioMain(private val reactContext: ReactApplicationContext) {
     optionMap: ReadableMap,
     promise: Promise) {
     try {
-      val options = AudioHelper.fromMap(optionMap)
-      val quality = options.quality
-      val realPath = Utils.getRealPath(fileUrl, reactContext)
-      Utils.addLog(fileUrl + "\n realPath= " + realPath)
-      AudioCompressor.CompressAudio(realPath!!, quality!!,reactContext,promise)
+
+      AudioCompressor.CompressAudio(fileUrl,optionMap,reactContext,promise)
     } catch (ex: Exception) {
       promise.reject(ex)
     }

package/android/src/main/java/com/reactnativecompressor/Utils/createVideoThumbnail.kt

@@ -8,7 +8,6 @@ import android.net.Uri
 import android.os.Build
 import android.text.TextUtils
 import android.webkit.URLUtil
-import androidx.annotation.RequiresApi
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.GuardedResultAsyncTask
 import com.facebook.react.bridge.Promise
@@ -39,7 +38,6 @@ class CreateVideoThumbnailClass(private val reactContext: ReactApplicationContex
             weakContext = WeakReference(reactContext.applicationContext)
         }
 
-        @RequiresApi(Build.VERSION_CODES.N)
         override fun doInBackgroundGuarded(): ReadableMap? {
             val format = "jpeg"
             val cacheName = if (options.hasKey("cacheName")) options.getString("cacheName") else ""

package/android/src/main/java/com/reactnativecompressor/Video/VideoMain.kt

@@ -65,17 +65,17 @@ class VideoMain(private val reactContext: ReactApplicationContext) {
       val metaRetriever = MediaMetadataRetriever()
       metaRetriever.setDataSource(srcPath)
       val file = File(srcPath)
-      val sizeInKBs = (file.length() / 1024).toFloat()
+      val sizeInKBs = (file.length() / 1024).toDouble()
       val actualHeight = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt()
       val actualWidth = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt()
-      val duration = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)!!.toLong()
+      val duration = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DURATION)!!.toDouble()
       val creationTime = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_DATE)
       val extension = filePath!!.substring(filePath.lastIndexOf(".") + 1)
       val params = Arguments.createMap()
-      params.putString("size", sizeInKBs.toString())
-      params.putString("width", actualWidth.toString())
-      params.putString("height", actualHeight.toString())
-      params.putString("duration", (duration / 1000).toString())
+      params.putDouble("size", sizeInKBs)
+      params.putInt("width", actualWidth)
+      params.putInt("height", actualHeight)
+      params.putDouble("duration", duration / 1000)
       params.putString("extension", extension)
       params.putString("creationTime", creationTime.toString())
       promise.resolve(params)

package/ios/Audio/AudioHelper.swift

@@ -0,0 +1,49 @@
+//
+//  AudioHelper.swift
+//  react-native-compressor
+//
+//  Created by Numan on 12/11/2023.
+//
+
+import AVFoundation
+
+class AudioHelper {
+    
+    static func getAudioBitrate(path: String) -> Int {
+        let audioURL = URL(fileURLWithPath: path)
+        let avAsset = AVURLAsset(url: audioURL)
+        let keys: Set<URLResourceKey> = [.totalFileSizeKey, .fileSizeKey]
+        let resourceValues = try? audioURL.resourceValues(forKeys: keys)
+        let fileSize = resourceValues?.fileSize ?? resourceValues?.totalFileSize
+
+        // Calculate bitrate in kbps
+        if let fileSize = fileSize, avAsset.duration.seconds > 0 {
+            return Int(Double(fileSize) * 8 / avAsset.duration.seconds)
+        }
+        return 0
+    }
+    
+    static func getDestinationBitrateByQuality(path: String, quality: String) -> Int {
+            let originalBitrate = getAudioBitrate(path: path)
+            var destinationBitrate = originalBitrate
+            print("source bitrate: \(originalBitrate)")
+
+            // Calculate the percentage of the original bitrate relative to the range 64000 to 320000
+            let percentage = Double(originalBitrate - 64000) / Double(320000 - 64000)
+
+            switch quality.lowercased() {
+            case "low":
+                destinationBitrate = max(64000, Int(Double(originalBitrate) * 0.3))
+            case "medium":
+                // Set destination bitrate to 60% of the original bitrate
+                destinationBitrate = Int(Double(originalBitrate) * 0.5)
+            case "high":
+                // Set destination bitrate to 80% of the original bitrate
+                destinationBitrate = min(320000,Int(Double(originalBitrate) * 0.7))
+            default:
+                print("Invalid quality level. Please enter 'low', 'medium', or 'high'.")
+            }
+            
+            return destinationBitrate
+        }
+}

package/ios/Audio/AudioMain.swift

@@ -5,16 +5,21 @@
 //  Created by Numan on 10/09/2023.
 //
 
-import Foundation
+
 import AVFoundation
+
+
+
 let AlAsset_Library_Scheme = "assets-library"
 class AudioMain{
     static func compress_audio(_ fileUrl: String, optionMap: NSDictionary, resolve: @escaping RCTPromiseResolveBlock, reject: @escaping RCTPromiseRejectBlock) {
         do {
             var fileUrl = fileUrl
+            
             if fileUrl.hasPrefix("file://") {
                 fileUrl = fileUrl.replacingOccurrences(of: "file://", with: "")
             }
+          
             let fileManager = FileManager.default
             var isDir: ObjCBool = false
             if !fileManager.fileExists(atPath: fileUrl, isDirectory: &isDir) || isDir.boolValue {
@@ -23,93 +28,52 @@ class AudioMain{
                 return
             }
             
-            let assetOptions: [String: Any] = [AVURLAssetPreferPreciseDurationAndTimingKey: true]
-            let asset = AVURLAsset(url: URL(fileURLWithPath: fileUrl), options: assetOptions)
-            let quality = optionMap["quality"] as? String ?? ""
-            let qualityConstant = getAudioQualityConstant(quality)
-            auto_compress_helper(asset, qualityConstant: qualityConstant) { mp3Path, finished in
-                if finished {
-                    resolve("file://\(mp3Path ?? "")")
-                } else {
-                    reject("Error", "Something went wrong", nil)
-                }
-            }
-        } catch {
-            reject(error.localizedDescription, error.localizedDescription, nil)
-        }
-    }
-    
-    static func getAudioQualityConstant(_ quality: String) -> String {
-        let audioQualityArray = ["low", "medium", "high"]
-        if let index = audioQualityArray.firstIndex(of: quality) {
-            switch index {
-            case 0:
-                return AVAssetExportPresetLowQuality
-            case 1:
-                return AVAssetExportPresetMediumQuality
-            case 2:
-                return AVAssetExportPresetHighestQuality
-            default:
-                return AVAssetExportPresetMediumQuality
+            let audioOptions = AudioOptions.fromDictionary((optionMap as! [String : Any]))
+            let outputMp3Path = "file://\(Utils.generateCacheFilePath("m4a"))"
+            
+            let oldUfileUrlRL = URL(string: fileUrl)!
+            let newURL = URL(string: outputMp3Path)!
+            
+            var options = FormatConverter.Options()
+            
+            if(audioOptions.samplerate != -1){
+                options.sampleRate = Double(audioOptions.samplerate)
             }
-        }
-        return AVAssetExportPresetMediumQuality
-    }
-    
-    static func auto_compress_helper(_ avAsset: AVURLAsset, qualityConstant: String, complete completeCallback: @escaping (_ mp3Path: String?, _ finished: Bool) -> Void) {
-        var path: String
-        if avAsset.url.scheme == AlAsset_Library_Scheme {
-            path = avAsset.url.query ?? ""
-            if path.isEmpty {
-                completeCallback(nil, false)
-                return
+            
+            if(audioOptions.bitrate != -1){
+                options.bitRate = UInt32(audioOptions.bitrate)
             }
-        } else {
-            path = avAsset.url.path
-            if path.isEmpty || !FileManager.default.fileExists(atPath: path) {
-                completeCallback(nil, false)
-                return
+            else
+            {
+                let bitrate = AudioHelper.getDestinationBitrateByQuality(path: fileUrl,quality: audioOptions.quality)
+                print("output bitrate: \(bitrate)")
+                options.bitRate = UInt32(bitrate)
             }
-        }
-        
-        let mp3Path = Utils.generateCacheFilePath("m4a")
-        
-        if FileManager.default.fileExists(atPath: mp3Path) {
-            completeCallback(mp3Path, true)
-            return
-        }
-        
-        let compatiblePresets = AVAssetExportSession.exportPresets(compatibleWith: avAsset)
-        
-        if compatiblePresets.contains(qualityConstant) {
-            let exportSession = AVAssetExportSession(asset: avAsset, presetName: AVAssetExportPresetAppleM4A)
             
-            let mp3Url = URL(fileURLWithPath: mp3Path)
-            exportSession?.outputURL = mp3Url
-            exportSession?.shouldOptimizeForNetworkUse = true
-            exportSession?.outputFileType = .m4a
             
-            exportSession?.exportAsynchronously(completionHandler: {
-                var finished = false
-                switch exportSession?.status {
-                case .failed:
-                    print("AVAssetExportSessionStatusFailed, error: \(exportSession?.error?.localizedDescription ?? "").")
-                case .cancelled:
-                    print("AVAssetExportSessionStatusCancelled.")
-                case .completed:
-                    print("AVAssetExportSessionStatusCompleted.")
-                    finished = true
-                case .unknown:
-                    print("AVAssetExportSessionStatusUnknown")
-                case .waiting:
-                    print("AVAssetExportSessionStatusWaiting")
-                case .exporting:
-                    print("AVAssetExportSessionStatusExporting")
-                default:
-                    break
+            if(audioOptions.channels != -1){
+                options.channels = UInt32(audioOptions.channels)
+            }
+         
+            options.format = .m4a
+            options.eraseFile = false
+            options.bitDepthRule = .any
+             
+            let converter = FormatConverter(inputURL: oldUfileUrlRL, outputURL: newURL, options: options)
+            converter.start { error in
+            // check to see if error isn't nil, otherwise you're good
+                if((error) != nil)
+                {
+                    print("error=> \(error?.localizedDescription)")
+                    reject(error?.localizedDescription,error?.localizedDescription, error)
+                    return
                 }
-                completeCallback(mp3Path, finished)
-            })
+               
+                resolve(newURL.absoluteString)
+            }
+            
+        } catch {
+            reject(error.localizedDescription, error.localizedDescription, nil)
         }
     }
 }

package/ios/Audio/AudioOptions.swift

@@ -0,0 +1,37 @@
+class AudioOptions: NSObject {
+    static func fromDictionary(_ dictionary: [String: Any]?) -> AudioOptions {
+        let options = AudioOptions()
+        
+        guard let dictionary = dictionary else {
+            return options
+        }
+        
+        for (key, value) in dictionary {
+            switch key {
+            case "quality":
+                options.quality = (value as? String) ?? "medium"
+            case "bitrate":
+                options.bitrate = (value as? Int) ?? -1
+            case "samplerate":
+                options.samplerate = (value as? Int) ?? -1
+            case "channels":
+                options.channels = (value as? Int) ?? -1
+           
+            default:
+                break
+            }
+        }
+        
+        return options
+    }
+
+    var quality: String = "medium"
+    var bitrate: Int = -1
+    var samplerate: Int = -1
+    var channels: Int = -1
+   
+    
+    override init() {
+        super.init()
+    }
+}