react-native-compressor 1.16.2 → 1.18.0

package/android/build.gradle

@@ -67,6 +67,9 @@ android {
     targetSdkVersion getExtOrIntegerDefault("targetSdkVersion")
     buildConfigField "boolean", "IS_NEW_ARCHITECTURE_ENABLED", isNewArchitectureEnabled().toString()
   }
+  buildFeatures {
+    buildConfig true
+  }
   buildTypes {
     release {
       minifyEnabled false

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

@@ -29,12 +29,12 @@ object Utils {
     }
 
     @JvmStatic
-    fun compressVideo(srcPath: String, destinationPath: String, resultWidth: Int, resultHeight: Int, videoBitRate: Float, uuid: String,progressDivider:Int, promise: Promise, reactContext: ReactApplicationContext) {
+    fun compressVideo(srcPath: String, destinationPath: String, resultWidth: Int, resultHeight: Int, videoBitRate: Float, frameRate: Int, uuid: String,progressDivider:Int, stripAudio: Boolean = false, promise: Promise, reactContext: ReactApplicationContext) {
       val currentVideoCompression = intArrayOf(0)
       val videoCompressorClass: VideoCompressorClass? = VideoCompressorClass(reactContext);
       compressorExports[uuid] = videoCompressorClass
       videoCompressorClass?.start(
-        srcPath, destinationPath, resultWidth, resultHeight, videoBitRate.toInt(),
+        srcPath, destinationPath, resultWidth, resultHeight, videoBitRate.toInt(), frameRate, stripAudio,
         listener = object : CompressionListener {
           override fun onProgress(index: Int, percent: Float) {
             if (percent <= 100) {

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

@@ -10,7 +10,6 @@ import java.io.File
 
 object AutoVideoCompression {
     fun createCompressionSettings(fileUrl: String?, options: VideoCompressorHelper, promise: Promise, reactContext: ReactApplicationContext?) {
-        val maxSize = options.maxSize
         val minimumFileSizeForCompress = options.minimumFileSizeForCompress
         try {
             val uri = Uri.parse(fileUrl)
@@ -22,18 +21,34 @@ object AutoVideoCompression {
             val sizeInMb = sizeInBytes / (1024 * 1024)
             if (sizeInMb > minimumFileSizeForCompress) {
                 val destinationPath = generateCacheFilePath("mp4", reactContext!!)
-                val actualHeight = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt()
-                val actualWidth = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt()
-                val bitrate = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)!!.toInt()
-                val scale = if (actualWidth > actualHeight) maxSize / actualWidth else maxSize / actualHeight
-                val resultWidth = Math.round(actualWidth * Math.min(scale, 1f) / 2) * 2
-                val resultHeight = Math.round(actualHeight * Math.min(scale, 1f) / 2) * 2
-                val videoBitRate = makeVideoBitrate(
-                  actualHeight, actualWidth,
-                  bitrate,
-                  resultHeight, resultWidth
-                ).toFloat()
-                compressVideo(srcPath!!, destinationPath, resultWidth, resultHeight, videoBitRate, options.uuid!!,options.progressDivider!!, promise, reactContext)
+                val actualHeight = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
+                val actualWidth = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
+                val bitrate = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_BITRATE)
+                val frameRate = VideoCompressorHelper.getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
+                if (actualHeight <= 0 || actualWidth <= 0) {
+                    promise.reject(Throwable("Failed to read the input video dimensions"))
+                    return
+                }
+                val profile = VideoCompressionProfileFactory.createAuto(
+                    sourceWidth = actualWidth,
+                    sourceHeight = actualHeight,
+                    sourceBitrate = bitrate,
+                    sourceFrameRate = frameRate,
+                    maxSize = options.maxSize,
+                )
+                compressVideo(
+                    srcPath!!,
+                    destinationPath,
+                    profile.width,
+                    profile.height,
+                    profile.bitrate.toFloat(),
+                    profile.frameRate,
+                    options.uuid!!,
+                    options.progressDivider!!,
+                    options.stripAudio,
+                    promise,
+                    reactContext,
+                )
             } else {
                 promise.resolve(fileUrl)
             }
@@ -41,23 +56,4 @@ object AutoVideoCompression {
             promise.reject(ex)
         }
     }
-
-    fun makeVideoBitrate(originalHeight: Int, originalWidth: Int, originalBitrate: Int, height: Int, width: Int): Int {
-        val compressFactor = 0.8f
-        val minCompressFactor = 0.8f
-        val maxBitrate = 1669000
-        var remeasuredBitrate = (originalBitrate / Math.min(originalHeight / height.toFloat(), originalWidth / width.toFloat())).toInt()
-        remeasuredBitrate = (remeasuredBitrate * compressFactor).toInt()
-        val minBitrate = (getVideoBitrateWithFactor(minCompressFactor) / (1280f * 720f / (width * height))).toInt()
-        if (originalBitrate < minBitrate) {
-            return remeasuredBitrate
-        }
-        return if (remeasuredBitrate > maxBitrate) {
-            maxBitrate
-        } else Math.max(remeasuredBitrate, minBitrate)
-    }
-
-    private fun getVideoBitrateWithFactor(f: Float): Int {
-        return (f * 2000f * 1000f * 1.13f).toInt()
-    }
 }

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

@@ -0,0 +1,144 @@
+package com.reactnativecompressor.Video
+
+import kotlin.math.max
+import kotlin.math.min
+import kotlin.math.roundToInt
+
+data class VideoCompressionProfile(
+    val width: Int,
+    val height: Int,
+    val bitrate: Int,
+    val frameRate: Int,
+)
+
+object VideoCompressionProfileFactory {
+    private const val DEFAULT_FRAME_RATE = 30
+
+    fun createAuto(
+        sourceWidth: Int,
+        sourceHeight: Int,
+        sourceBitrate: Int,
+        sourceFrameRate: Int,
+        maxSize: Float,
+    ): VideoCompressionProfile {
+        val dimensions = scaleWithin(sourceWidth, sourceHeight, maxSize.roundToInt())
+        val frameRate = normalizeFrameRate(sourceFrameRate)
+        val bitrate = estimateBitrate(
+            sourceWidth = sourceWidth,
+            sourceHeight = sourceHeight,
+            sourceBitrate = sourceBitrate,
+            sourceFrameRate = sourceFrameRate,
+            targetWidth = dimensions.first,
+            targetHeight = dimensions.second,
+            targetFrameRate = frameRate,
+        )
+
+        return VideoCompressionProfile(
+            width = dimensions.first,
+            height = dimensions.second,
+            bitrate = bitrate,
+            frameRate = frameRate,
+        )
+    }
+
+    fun createManual(
+        sourceWidth: Int,
+        sourceHeight: Int,
+        sourceBitrate: Int,
+        sourceFrameRate: Int,
+        maxSize: Float,
+        requestedBitrate: Float,
+    ): VideoCompressionProfile {
+        val dimensions = scaleWithin(sourceWidth, sourceHeight, maxSize.roundToInt())
+        val frameRate = normalizeFrameRate(sourceFrameRate)
+        val bitrate = if (requestedBitrate > 0f) {
+            requestedBitrate.roundToInt().coerceAtLeast(1)
+        } else {
+            estimateBitrate(
+                sourceWidth = sourceWidth,
+                sourceHeight = sourceHeight,
+                sourceBitrate = sourceBitrate,
+                sourceFrameRate = sourceFrameRate,
+                targetWidth = dimensions.first,
+                targetHeight = dimensions.second,
+                targetFrameRate = frameRate,
+            )
+        }
+
+        return VideoCompressionProfile(
+            width = dimensions.first,
+            height = dimensions.second,
+            bitrate = bitrate,
+            frameRate = frameRate,
+        )
+    }
+
+    fun normalizeDimension(value: Int): Int {
+        val positive = value.coerceAtLeast(2)
+        return if (positive % 2 == 0) positive else positive - 1
+    }
+
+    private fun scaleWithin(sourceWidth: Int, sourceHeight: Int, requestedMaxSize: Int): Pair<Int, Int> {
+        val safeWidth = normalizeDimension(sourceWidth)
+        val safeHeight = normalizeDimension(sourceHeight)
+        val longSide = max(safeWidth, safeHeight)
+        val boundedMaxSize = requestedMaxSize.coerceAtLeast(2)
+
+        if (longSide <= boundedMaxSize) {
+            return Pair(safeWidth, safeHeight)
+        }
+
+        val scale = boundedMaxSize.toFloat() / longSide.toFloat()
+        val width = normalizeDimension((safeWidth * scale).roundToInt())
+        val height = normalizeDimension((safeHeight * scale).roundToInt())
+        return Pair(width, height)
+    }
+
+    private fun normalizeFrameRate(sourceFrameRate: Int): Int {
+        if (sourceFrameRate <= 0) {
+            return DEFAULT_FRAME_RATE
+        }
+
+        return sourceFrameRate.coerceIn(1, DEFAULT_FRAME_RATE)
+    }
+
+    private fun estimateBitrate(
+        sourceWidth: Int,
+        sourceHeight: Int,
+        sourceBitrate: Int,
+        sourceFrameRate: Int,
+        targetWidth: Int,
+        targetHeight: Int,
+        targetFrameRate: Int,
+    ): Int {
+        val targetLongSide = max(targetWidth, targetHeight)
+        val floor = when {
+            targetLongSide >= 1920 -> 4_000_000
+            targetLongSide >= 1280 -> 2_200_000
+            targetLongSide >= 960 -> 1_600_000
+            targetLongSide >= 720 -> 1_200_000
+            else -> 850_000
+        }
+        val ceiling = when {
+            targetLongSide >= 1920 -> 8_000_000
+            targetLongSide >= 1280 -> 5_000_000
+            targetLongSide >= 960 -> 3_500_000
+            targetLongSide >= 720 -> 2_500_000
+            else -> 1_500_000
+        }
+
+        if (sourceBitrate <= 0) {
+            return floor
+        }
+
+        val sourcePixels = sourceWidth.toLong() * sourceHeight.toLong()
+        val targetPixels = targetWidth.toLong() * targetHeight.toLong()
+        val pixelRatio = if (sourcePixels == 0L) 1.0 else targetPixels.toDouble() / sourcePixels.toDouble()
+        val sourceFps = max(sourceFrameRate, 1)
+        val frameRateRatio = targetFrameRate.toDouble() / sourceFps.toDouble()
+        val scaledBitrate = (sourceBitrate * pixelRatio * max(frameRateRatio, 0.85)).roundToInt()
+        val sourceCap = (sourceBitrate * 0.95).roundToInt().coerceAtLeast(floor)
+
+        return scaledBitrate.coerceAtLeast(floor).coerceAtMost(min(ceiling, sourceCap))
+    }
+}

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/VideoCompressorClass.kt

@@ -24,6 +24,8 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
     outputWidth: Int,
     outputHeight: Int,
     bitrate: Int,
+    frameRate: Int,
+    stripAudio: Boolean = false,
     listener: CompressionListener,
   ) {
     val uris = mutableListOf<Uri>()
@@ -36,6 +38,8 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
       outputWidth,
       outputHeight,
       bitrate,
+      frameRate,
+      stripAudio,
       listener,
       destPath
     )
@@ -52,6 +56,8 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
     outputWidth: Int,
     outputHeight: Int,
     bitrate: Int,
+    frameRate: Int,
+    stripAudio: Boolean,
     listener: CompressionListener,
     destPath: String
   ) {
@@ -74,6 +80,8 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
             outputWidth,
             outputHeight,
             bitrate,
+            frameRate,
+            stripAudio,
             listener,
           )
 
@@ -96,6 +104,8 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
     outputWidth: Int,
     outputHeight: Int,
     bitrate: Int,
+    frameRate: Int,
+    disableAudio: Boolean = false,
     listener: CompressionListener,
   ): Result = withContext(Dispatchers.Default) {
     return@withContext compressVideo(
@@ -107,6 +117,8 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
       outputWidth,
       outputHeight,
       bitrate,
+      frameRate,
+      disableAudio,
       object : CompressionProgressListener {
         override fun onProgressChanged(index: Int, percent: Float) {
           listener.onProgress(index, percent)

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/compressor/Compressor.kt

@@ -54,6 +54,8 @@ object Compressor {
     outputWidth: Int,
     outputHeight: Int,
     outputBitrate: Int,
+    outputFrameRate: Int,
+    disableAudio: Boolean = false,
     listener: CompressionProgressListener,
   ): Result = withContext(Dispatchers.Default) {
 
@@ -123,8 +125,9 @@ object Compressor {
       newHeight!!,
       destination,
       newBitrate,
+      outputFrameRate,
       streamableFile,
-      false,
+      disableAudio,
       extractor,
       listener,
       duration,
@@ -140,6 +143,7 @@ object Compressor {
     newHeight: Int,
     destination: String,
     newBitrate: Int,
+    outputFrameRate: Int,
     streamableFile: String?,
     disableAudio: Boolean,
     extractor: MediaExtractor,
@@ -178,6 +182,7 @@ object Compressor {
           inputFormat,
           outputFormat,
           newBitrate,
+          outputFrameRate,
         )
 
         val decoder: MediaCodec
@@ -374,7 +379,7 @@ object Compressor {
                         }
           }
 
-        } catch (exception: Exception) {
+        } catch (exception: Throwable) {
           printException(exception)
           return Result(id, success = false, failureMessage = exception.message)
         }
@@ -400,12 +405,14 @@ object Compressor {
         extractor.release()
         try {
           mediaMuxer.finishMovie()
-        } catch (e: Exception) {
+        } catch (e: Throwable) {
           printException(e)
+          return Result(id, success = false, failureMessage = e.message ?: "Failed to finalize compressed video")
         }
 
-      } catch (exception: Exception) {
+      } catch (exception: Throwable) {
         printException(exception)
+        return Result(id, success = false, failureMessage = exception.message)
       }
 
       var resultFile = cacheFile
@@ -423,6 +430,13 @@ object Compressor {
           printException(e)
         }
       }
+      if (!resultFile.exists() || resultFile.length() <= 32) {
+        return Result(
+          id,
+          success = false,
+          failureMessage = "Compressed video output is invalid"
+        )
+      }
       return Result(
         id,
         success = true,

package/android/src/main/java/com/reactnativecompressor/Video/VideoCompressor/utils/CompressorUtils.kt

@@ -70,8 +70,9 @@ object CompressorUtils {
     inputFormat: MediaFormat,
     outputFormat: MediaFormat,
     newBitrate: Int,
+    targetFrameRate: Int,
   ) {
-    val newFrameRate = getFrameRate(inputFormat)
+    val newFrameRate = targetFrameRate.coerceAtLeast(1)
     val iFrameInterval = getIFrameIntervalRate(inputFormat)
     outputFormat.apply {
       setInteger(
@@ -107,12 +108,6 @@ object CompressorUtils {
     }
   }
 
-  // Get the frame rate from the input format or use a default value
-  private fun getFrameRate(format: MediaFormat): Int {
-    return if (format.containsKey(MediaFormat.KEY_FRAME_RATE)) format.getInteger(MediaFormat.KEY_FRAME_RATE)
-    else 30
-  }
-
   // Get the I-frame (keyframe) interval from the input format or use a default value
   private fun getIFrameIntervalRate(format: MediaFormat): Int {
     return if (format.containsKey(MediaFormat.KEY_I_FRAME_INTERVAL)) format.getInteger(
@@ -172,7 +167,7 @@ object CompressorUtils {
   /**
    * Log an exception with a meaningful message.
    */
-  fun printException(exception: Exception) {
+  fun printException(exception: Throwable) {
     var message = "An error has occurred!"
     exception.localizedMessage?.let {
       message = it

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

@@ -27,6 +27,7 @@ class VideoCompressorHelper {
     var maxSize = 640.0f
     var progressDivider: Int? = 0
     var minimumFileSizeForCompress = 0.0f
+    var stripAudio = false
 
     companion object {
         private var _reactContext: ReactApplicationContext? = null
@@ -84,10 +85,21 @@ class VideoCompressorHelper {
                     "minimumFileSizeForCompress" -> options.minimumFileSizeForCompress = map.getDouble(key).toFloat()
                     "bitrate" -> options.bitrate = map.getDouble(key).toFloat()
                     "progressDivider" -> options.progressDivider = map.getInt(key)
+                    "stripAudio" -> options.stripAudio = map.getBoolean(key)
                 }
             }
             return options
         }
+
+        fun getMetadataInt(metaRetriever: MediaMetadataRetriever, key: Int): Int {
+            return metaRetriever.extractMetadata(key)
+                ?.toDoubleOrNull()
+                ?.toLong()
+                ?.coerceIn(0L, Int.MAX_VALUE.toLong())
+                ?.toInt()
+                ?: 0
+        }
+
         fun VideoCompressManual(fileUrl: String?, options: VideoCompressorHelper, promise: Promise, reactContext: ReactApplicationContext?) {
             try {
                 val uri = Uri.parse(fileUrl)
@@ -95,24 +107,35 @@ class VideoCompressorHelper {
                 val destinationPath = Utils.generateCacheFilePath("mp4", reactContext!!)
                 val metaRetriever = MediaMetadataRetriever()
                 metaRetriever.setDataSource(srcPath)
-                var height = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)!!.toInt()
-                var width = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)!!.toInt()
-                val bitrate = metaRetriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_BITRATE)!!.toInt()
-                val isPortrait = height > width
-                val maxSize = options.maxSize.toInt()
-                if (isPortrait && height > maxSize) {
-                    width = (maxSize.toFloat() / height * width).toInt()
-                    height = maxSize
-                } else if (width > maxSize) {
-                    height = (maxSize.toFloat() / width * height).toInt()
-                    width = maxSize
-                } else {
-                    if (options.bitrate == 0f) {
-                        options.bitrate = (bitrate * 0.8).toInt().toFloat()
-                    }
+                val height = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
+                val width = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
+                val bitrate = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_BITRATE)
+                val frameRate = getMetadataInt(metaRetriever, MediaMetadataRetriever.METADATA_KEY_CAPTURE_FRAMERATE)
+                if (height <= 0 || width <= 0) {
+                    promise.reject(Throwable("Failed to read the input video dimensions"))
+                    return
                 }
-                val videoBitRate = if (options.bitrate > 0) options.bitrate else (height * width * 1.5).toFloat()
-                Utils.compressVideo(srcPath!!, destinationPath, width, height, videoBitRate, options.uuid!!,options.progressDivider!!, promise, reactContext)
+                val profile = VideoCompressionProfileFactory.createManual(
+                    sourceWidth = width,
+                    sourceHeight = height,
+                    sourceBitrate = bitrate,
+                    sourceFrameRate = frameRate,
+                    maxSize = options.maxSize,
+                    requestedBitrate = options.bitrate,
+                )
+                Utils.compressVideo(
+                    srcPath!!,
+                    destinationPath,
+                    profile.width,
+                    profile.height,
+                    profile.bitrate.toFloat(),
+                    profile.frameRate,
+                    options.uuid!!,
+                    options.progressDivider!!,
+                    options.stripAudio,
+                    promise,
+                    reactContext,
+                )
             } catch (ex: Exception) {
                 promise.reject(ex)
             }

package/ios/Video/NextLevelSessionExporter.swift

@@ -70,6 +70,9 @@ open class NextLevelSessionExporter: NSObject {
     
     /// Audio output configuration dictionary, using keys defined in `<AVFoundation/AVAudioSettings.h>`
     public var audioOutputConfiguration: [String : Any]?
+
+    /// When true, audio tracks are excluded from the export entirely.
+    public var stripAudio: Bool = false
     
     /// Export session status state.
     public var status: AVAssetExportSession.Status {
@@ -247,8 +250,10 @@ extension NextLevelSessionExporter {
         }
         
         self.setupVideoOutput(withAsset: asset)
-        self.setupAudioOutput(withAsset: asset)
-        self.setupAudioInput()
+        if !self.stripAudio {
+            self.setupAudioOutput(withAsset: asset)
+            self.setupAudioInput()
+        }
         
         // export
         

package/ios/Video/VideoMain.swift

@@ -104,11 +104,11 @@ class VideoCompressor {
 
       VideoCompressor.getAbsoluteVideoPath(url.absoluteString, options: options) { absoluteVideoPath in
         var minimumFileSizeForCompress:Double=0.0;
-          let videoURL = URL(string: absoluteVideoPath)
+        let videoURL = URL(string: absoluteVideoPath)
         let fileSize=self.getfileSize(forURL: videoURL!);
-          if((options["minimumFileSizeForCompress"]) != nil)
-        {0
-              minimumFileSizeForCompress=options["minimumFileSizeForCompress"] as! Double;
+        if((options["minimumFileSizeForCompress"]) != nil)
+        {
+              minimumFileSizeForCompress=(options["minimumFileSizeForCompress"] as? NSNumber)?.doubleValue ?? 0;
         }
         if(fileSize>minimumFileSizeForCompress)
         {
@@ -146,55 +146,129 @@ class VideoCompressor {
 }
 
 
-    func  makeVideoBitrate(originalHeight:Int,originalWidth:Int,originalBitrate:Int,height:Int,width:Int)->Int {
-        let compressFactor:Float = 0.8
-        let  minCompressFactor:Float = 0.8
-        let maxBitrate:Int = 1669000
-        let minValue:Float=min(Float(originalHeight)/Float(height),Float(originalWidth)/Float(width))
-        var remeasuredBitrate:Int = Int(Float(originalBitrate) / minValue)
-        remeasuredBitrate = Int(Float(remeasuredBitrate)*compressFactor)
-        let minBitrate:Int = Int(Float(self.getVideoBitrateWithFactor(f: minCompressFactor)) / (1280 * 720 / Float(width * height)))
-        if (originalBitrate < minBitrate) {
-          return remeasuredBitrate;
+    struct CompressionProfile {
+        let width: Int
+        let height: Int
+        let bitrate: Int
+        let frameRate: Int
+    }
+
+    func normalizeDimension(_ value: CGFloat) -> Int {
+        let rounded = max(Int(value.rounded()), 2)
+        return rounded % 2 == 0 ? rounded : rounded - 1
+    }
+
+    func normalizeFrameRate(for track: AVAssetTrack) -> Int {
+        let nominalFrameRate = Int(track.nominalFrameRate.rounded())
+        if nominalFrameRate <= 0 {
+            return 30
+        }
+
+        return min(max(nominalFrameRate, 1), 30)
+    }
+
+    func scaledDimensions(width: CGFloat, height: CGFloat, maxSize: CGFloat) -> (width: Int, height: Int) {
+        let safeWidth = normalizeDimension(width)
+        let safeHeight = normalizeDimension(height)
+        let longSide = max(safeWidth, safeHeight)
+        let safeMaxSize = max(Int(maxSize.rounded()), 2)
+
+        guard longSide > safeMaxSize else {
+            return (safeWidth, safeHeight)
         }
-        if (remeasuredBitrate > maxBitrate) {
-          return maxBitrate;
+
+        let scale = CGFloat(safeMaxSize) / CGFloat(longSide)
+        return (
+            normalizeDimension(CGFloat(safeWidth) * scale),
+            normalizeDimension(CGFloat(safeHeight) * scale)
+        )
+    }
+
+    func estimateBitrate(
+        originalWidth: Int,
+        originalHeight: Int,
+        originalBitrate: Int,
+        originalFrameRate: Int,
+        targetWidth: Int,
+        targetHeight: Int,
+        targetFrameRate: Int
+    ) -> Int {
+        let targetLongSide = max(targetWidth, targetHeight)
+        let floor: Int
+        let ceiling: Int
+
+        switch targetLongSide {
+        case 1920...:
+            floor = 4_000_000
+            ceiling = 8_000_000
+        case 1280...1919:
+            floor = 2_200_000
+            ceiling = 5_000_000
+        case 960...1279:
+            floor = 1_600_000
+            ceiling = 3_500_000
+        case 720...959:
+            floor = 1_200_000
+            ceiling = 2_500_000
+        default:
+            floor = 850_000
+            ceiling = 1_500_000
         }
-        return max(remeasuredBitrate, minBitrate);
-      }
-    func getVideoBitrateWithFactor(f:Float)->Int {
-        return Int(f * 2000 * 1000 * 1.13);
-      }
+
+        guard originalBitrate > 0 else {
+            return floor
+        }
+
+        let originalPixels = max(originalWidth * originalHeight, 1)
+        let targetPixels = max(targetWidth * targetHeight, 1)
+        let pixelRatio = Double(targetPixels) / Double(originalPixels)
+        let safeOriginalFrameRate = max(originalFrameRate, 1)
+        let frameRateRatio = Double(targetFrameRate) / Double(safeOriginalFrameRate)
+        let scaledBitrate = Int((Double(originalBitrate) * pixelRatio * max(frameRateRatio, 0.85)).rounded())
+        let sourceCap = max(Int((Double(originalBitrate) * 0.95).rounded()), floor)
+        return min(max(scaledBitrate, floor), min(ceiling, sourceCap))
+    }
+
+    func createCompressionProfile(track: AVAssetTrack, maxSize: CGFloat, requestedBitrate: Int?) -> CompressionProfile {
+        let videoSize = track.naturalSize.applying(track.preferredTransform)
+        let actualWidth = abs(videoSize.width)
+        let actualHeight = abs(videoSize.height)
+        let dimensions = scaledDimensions(width: actualWidth, height: actualHeight, maxSize: maxSize)
+        let frameRate = normalizeFrameRate(for: track)
+        let sourceFrameRate = Int(track.nominalFrameRate.rounded())
+        let bitrate = (requestedBitrate != nil && requestedBitrate! > 0) ? requestedBitrate! : estimateBitrate(
+            originalWidth: normalizeDimension(actualWidth),
+            originalHeight: normalizeDimension(actualHeight),
+            originalBitrate: Int(abs(track.estimatedDataRate.rounded())),
+            originalFrameRate: sourceFrameRate,
+            targetWidth: dimensions.width,
+            targetHeight: dimensions.height,
+            targetFrameRate: frameRate
+        )
+
+        return CompressionProfile(
+            width: dimensions.width,
+            height: dimensions.height,
+            bitrate: max(bitrate, 1),
+            frameRate: frameRate
+        )
+    }
 
     func autoCompressionHelper(url: URL, options: [String: Any], onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
-        let maxSize:Float = options["maxSize"] as! Float;
+        let maxSize = (options["maxSize"] as? NSNumber)?.floatValue ?? 640
         let uuid:String = options["uuid"] as! String
         let progressDivider=options["progressDivider"] as? Int ?? 0
+        let stripAudio=options["stripAudio"] as? Bool ?? false
 
         let asset = AVAsset(url: url)
-        guard asset.tracks.count >= 1 else {
+        guard let track = getVideoTrack(asset: asset) else {
           let error = CompressionError(message: "Invalid video URL, no track found")
           onFailure(error)
           return
         }
-        let track = getVideoTrack(asset: asset);
-
-        let videoSize = track.naturalSize.applying(track.preferredTransform);
-        let actualWidth = Float(abs(videoSize.width))
-        let actualHeight = Float(abs(videoSize.height))
-
-        let bitrate=Float(abs(track.estimatedDataRate));
-        let scale:Float = actualWidth > actualHeight ? (Float(maxSize) / actualWidth) : (Float(maxSize) / actualHeight);
-        let resultWidth:Float = round(actualWidth * min(scale, 1) / 2) * 2;
-        let resultHeight:Float = round(actualHeight * min(scale, 1) / 2) * 2;
-
-        let videoBitRate:Int = self.makeVideoBitrate(
-            originalHeight: Int(actualHeight), originalWidth: Int(actualWidth),
-            originalBitrate: Int(bitrate),
-            height: Int(resultHeight), width: Int(resultWidth)
-            );
+        let profile = createCompressionProfile(track: track, maxSize: CGFloat(maxSize), requestedBitrate: nil)
 
-        exportVideoHelper(url: url, asset: asset, bitRate: videoBitRate, resultWidth: resultWidth, resultHeight: resultHeight,uuid: uuid,progressDivider: progressDivider) { progress in
+        exportVideoHelper(url: url, asset: asset, bitRate: profile.bitrate, frameRate: profile.frameRate, resultWidth: profile.width, resultHeight: profile.height,uuid: uuid,progressDivider: progressDivider, stripAudio: stripAudio) { progress in
             onProgress(progress)
         } onCompletion: { outputURL in
             onCompletion(outputURL)
@@ -205,36 +279,19 @@ class VideoCompressor {
 
     func manualCompressionHelper(url: URL, options: [String: Any], onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
         let uuid:String = options["uuid"] as! String
-        var bitRate = (options["bitrate"] as? NSNumber)?.floatValue;
+        let bitRate = (options["bitrate"] as? NSNumber)?.intValue
         let progressDivider=options["progressDivider"] as? Int ?? 0
+        let stripAudio=options["stripAudio"] as? Bool ?? false
         let asset = AVAsset(url: url)
-        guard asset.tracks.count >= 1 else {
+        guard let track = getVideoTrack(asset: asset) else {
           let error = CompressionError(message: "Invalid video URL, no track found")
           onFailure(error)
           return
         }
-        let track = getVideoTrack(asset: asset);
-
-        let videoSize = track.naturalSize.applying(track.preferredTransform);
-        var width = Float(abs(videoSize.width))
-        var height = Float(abs(videoSize.height))
-        let isPortrait = height > width
-        let maxSize = (options["maxSize"] as! Float?) ?? Float(1920);
-        if(isPortrait && height > maxSize){
-          width = (maxSize/height)*width
-          height = maxSize
-        }else if(width > maxSize){
-          height = (maxSize/width)*height
-          width = maxSize
-        }
-        else
-        {
-            bitRate=bitRate ?? Float(abs(track.estimatedDataRate))*0.8
-        }
+        let maxSize = (options["maxSize"] as? NSNumber)?.floatValue ?? Float(1920)
+        let profile = createCompressionProfile(track: track, maxSize: CGFloat(maxSize), requestedBitrate: bitRate)
 
-        let videoBitRate = bitRate ?? height*width*1.5
-
-        exportVideoHelper(url: url, asset: asset, bitRate: Int(videoBitRate), resultWidth: width, resultHeight: height,uuid: uuid,progressDivider: progressDivider) { progress in
+        exportVideoHelper(url: url, asset: asset, bitRate: profile.bitrate, frameRate: profile.frameRate, resultWidth: profile.width, resultHeight: profile.height,uuid: uuid,progressDivider: progressDivider, stripAudio: stripAudio) { progress in
             onProgress(progress)
         } onCompletion: { outputURL in
             onCompletion(outputURL)
@@ -243,7 +300,7 @@ class VideoCompressor {
         }
       }
 
-    func exportVideoHelper(url: URL,asset: AVAsset, bitRate: Int,resultWidth:Float,resultHeight:Float,uuid:String,progressDivider: Int, onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
+    func exportVideoHelper(url: URL,asset: AVAsset, bitRate: Int, frameRate: Int, resultWidth:Int,resultHeight:Int,uuid:String,progressDivider: Int, stripAudio: Bool = false, onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
         var currentVideoCompression:Int=0
 
         var tmpURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
@@ -258,21 +315,26 @@ class VideoCompressor {
         let compressionDict: [String: Any] = [
           AVVideoAverageBitRateKey: bitRate,
           AVVideoProfileLevelKey: AVVideoProfileLevelH264HighAutoLevel,
+          AVVideoExpectedSourceFrameRateKey: frameRate,
+          AVVideoAverageNonDroppableFrameRateKey: frameRate,
         ]
         exporter.optimizeForNetworkUse = true;
         exporter.videoOutputConfiguration = [
           AVVideoCodecKey: AVVideoCodecType.h264,
           AVVideoWidthKey:  resultWidth,
           AVVideoHeightKey:  resultHeight,
-          AVVideoScalingModeKey: AVVideoScalingModeResizeAspectFill,
+          AVVideoScalingModeKey: AVVideoScalingModeResizeAspect,
           AVVideoCompressionPropertiesKey: compressionDict
         ]
-        exporter.audioOutputConfiguration = [
-          AVFormatIDKey: kAudioFormatMPEG4AAC,
-          AVEncoderBitRateKey: NSNumber(integerLiteral: 128000),
-          AVNumberOfChannelsKey: NSNumber(integerLiteral: 2),
-          AVSampleRateKey: NSNumber(value: Float(44100))
-        ]
+        exporter.stripAudio = stripAudio
+        if !stripAudio {
+            exporter.audioOutputConfiguration = [
+              AVFormatIDKey: kAudioFormatMPEG4AAC,
+              AVEncoderBitRateKey: NSNumber(integerLiteral: 128000),
+              AVNumberOfChannelsKey: NSNumber(integerLiteral: 2),
+              AVSampleRateKey: NSNumber(value: Float(44100))
+            ]
+        }
 
         compressorExports[uuid] = exporter
         exporter.export(progressHandler: { (progress) in
@@ -284,6 +346,7 @@ class VideoCompressor {
             }
         }, completionHandler: { result in
             currentVideoCompression=0;
+            self.compressorExports[uuid] = nil
             switch exporter.status {
             case .completed:
               onCompletion(exporter.outputURL!)
@@ -293,14 +356,17 @@ class VideoCompressor {
                 onFailure(error)
                 break
             default:
-                onCompletion(url)
+                onFailure(exporter.error ?? CompressionError(message: "Compression failed"))
               break
           }
         })
     }
 
-    func getVideoTrack(asset: AVAsset) -> AVAssetTrack {
+    func getVideoTrack(asset: AVAsset) -> AVAssetTrack? {
         let tracks = asset.tracks(withMediaType: AVMediaType.video)
+        guard tracks.count >= 1 else {
+            return nil
+        }
         return tracks[0];
         }
 

package/lib/commonjs/Video/index.js

@@ -52,6 +52,9 @@ const Video = {
       if (options?.minimumFileSizeForCompress !== undefined) {
         modifiedOptions.minimumFileSizeForCompress = options?.minimumFileSizeForCompress;
       }
+      if (options?.stripAudio) {
+        modifiedOptions.stripAudio = options.stripAudio;
+      }
       if (options?.getCancellationId) {
         options?.getCancellationId(uuid);
       }

package/lib/commonjs/Video/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["_reactNative","require","_Main","_utils","VideoCompressEventEmitter","NativeEventEmitter","Compressor","NativeVideoCompressor","cancelCompression","cancellationId","exports","Video","compress","fileUrl","options","onProgress","uuid","uuidv4","subscription","subscription2","addListener","event","data","progress","downloadProgress","modifiedOptions","progressDivider","bitrate","compressionMethod","maxSize","minimumFileSizeForCompress","undefined","getCancellationId","result","remove","activateBackgroundTask","onExpired","deactivateBackgroundTask","removeAllListeners","_default","default"],"sourceRoot":"../../../src","sources":["Video/index.tsx"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["_reactNative","require","_Main","_utils","VideoCompressEventEmitter","NativeEventEmitter","Compressor","NativeVideoCompressor","cancelCompression","cancellationId","exports","Video","compress","fileUrl","options","onProgress","uuid","uuidv4","subscription","subscription2","addListener","event","data","progress","downloadProgress","modifiedOptions","progressDivider","bitrate","compressionMethod","maxSize","minimumFileSizeForCompress","undefined","stripAudio","getCancellationId","result","remove","activateBackgroundTask","onExpired","deactivateBackgroundTask","removeAllListeners","_default","default"],"sourceRoot":"../../../src","sources":["Video/index.tsx"],"mappings":"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","ignoreList":[]}

package/lib/module/Video/index.js

@@ -47,6 +47,9 @@ const Video = {
       if (options?.minimumFileSizeForCompress !== undefined) {
         modifiedOptions.minimumFileSizeForCompress = options?.minimumFileSizeForCompress;
       }
+      if (options?.stripAudio) {
+        modifiedOptions.stripAudio = options.stripAudio;
+      }
       if (options?.getCancellationId) {
         options?.getCancellationId(uuid);
       }

package/lib/module/Video/index.js.map

@@ -1 +1 @@
-{"version":3,"names":["NativeEventEmitter","Compressor","uuidv4","VideoCompressEventEmitter","NativeVideoCompressor","cancelCompression","cancellationId","Video","compress","fileUrl","options","onProgress","uuid","subscription","subscription2","addListener","event","data","progress","downloadProgress","modifiedOptions","progressDivider","bitrate","compressionMethod","maxSize","minimumFileSizeForCompress","undefined","getCancellationId","result","remove","activateBackgroundTask","onExpired","deactivateBackgroundTask","removeAllListeners"],"sourceRoot":"../../../src","sources":["Video/index.tsx"],"mappings":"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","ignoreList":[]}
+{"version":3,"names":["NativeEventEmitter","Compressor","uuidv4","VideoCompressEventEmitter","NativeVideoCompressor","cancelCompression","cancellationId","Video","compress","fileUrl","options","onProgress","uuid","subscription","subscription2","addListener","event","data","progress","downloadProgress","modifiedOptions","progressDivider","bitrate","compressionMethod","maxSize","minimumFileSizeForCompress","undefined","stripAudio","getCancellationId","result","remove","activateBackgroundTask","onExpired","deactivateBackgroundTask","removeAllListeners"],"sourceRoot":"../../../src","sources":["Video/index.tsx"],"mappings":"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","ignoreList":[]}

package/lib/typescript/src/Video/index.d.ts

@@ -10,6 +10,11 @@ type videoCompresssionType = {
      * Default:0, we uses it when we use downloadProgress/onProgress
      */
     progressDivider?: number;
+    /***
+     * When true, the audio track is removed entirely from the output video.
+     * Default: false
+     */
+    stripAudio?: boolean;
 };
 export type VideoCompressorType = {
     compress(fileUrl: string, options?: videoCompresssionType, onProgress?: (progress: number) => void): Promise<string>;

package/lib/typescript/src/Video/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Video/index.tsx"],"names":[],"mappings":"AAKA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAClD,KAAK,qBAAqB,GAAG;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,iBAAiB,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;CAC1B,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,EAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrH,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,sBAAsB,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACtE,wBAAwB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;CAC1C,CAAC;AAMF,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,MAAM,QAEvD,CAAC;AAEF,QAAA,MAAM,KAAK,EAAE,mBAgFW,CAAC;AAEzB,eAAe,KAAK,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/Video/index.tsx"],"names":[],"mappings":"AAKA,MAAM,MAAM,iBAAiB,GAAG,MAAM,GAAG,QAAQ,CAAC;AAClD,KAAK,qBAAqB,GAAG;IAC3B,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iBAAiB,CAAC,EAAE,iBAAiB,CAAC;IACtC,0BAA0B,CAAC,EAAE,MAAM,CAAC;IACpC,iBAAiB,CAAC,EAAE,CAAC,cAAc,EAAE,MAAM,KAAK,IAAI,CAAC;IACrD,gBAAgB,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,CAAC;IAC9C;;OAEG;IACH,eAAe,CAAC,EAAE,MAAM,CAAC;IACzB;;;OAGG;IACH,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB,CAAC;AAEF,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,EAAE,OAAO,CAAC,EAAE,qBAAqB,EAAE,UAAU,CAAC,EAAE,CAAC,QAAQ,EAAE,MAAM,KAAK,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACrH,iBAAiB,CAAC,cAAc,EAAE,MAAM,GAAG,IAAI,CAAC;IAChD,sBAAsB,CAAC,SAAS,CAAC,EAAE,CAAC,IAAI,EAAE,GAAG,KAAK,IAAI,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACtE,wBAAwB,IAAI,OAAO,CAAC,GAAG,CAAC,CAAC;CAC1C,CAAC;AAMF,eAAO,MAAM,iBAAiB,GAAI,gBAAgB,MAAM,QAEvD,CAAC;AAEF,QAAA,MAAM,KAAK,EAAE,mBAoFW,CAAC;AAEzB,eAAe,KAAK,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-compressor",
-  "version": "1.16.2",
+  "version": "1.18.0",
   "description": "Compress Image, Video, and Audio same like Whatsapp & Auto/Manual Compression | Background Upload | Download File | Create Video Thumbnail",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",

package/src/Video/index.tsx

@@ -15,6 +15,11 @@ type videoCompresssionType = {
    * Default:0, we uses it when we use downloadProgress/onProgress
    */
   progressDivider?: number;
+  /***
+   * When true, the audio track is removed entirely from the output video.
+   * Default: false
+   */
+  stripAudio?: boolean;
 };
 
 export type VideoCompressorType = {
@@ -63,6 +68,7 @@ const Video: VideoCompressorType = {
         maxSize?: number;
         minimumFileSizeForCompress?: number;
         progressDivider?: number;
+        stripAudio?: boolean;
       } = { uuid };
       if (options?.progressDivider) modifiedOptions.progressDivider = options?.progressDivider;
       if (options?.bitrate) modifiedOptions.bitrate = options?.bitrate;
@@ -79,6 +85,9 @@ const Video: VideoCompressorType = {
       if (options?.minimumFileSizeForCompress !== undefined) {
         modifiedOptions.minimumFileSizeForCompress = options?.minimumFileSizeForCompress;
       }
+      if (options?.stripAudio) {
+        modifiedOptions.stripAudio = options.stripAudio;
+      }
       if (options?.getCancellationId) {
         options?.getCancellationId(uuid);
       }