react-native-compressor 1.16.2 → 1.17.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, 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,
         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,33 @@ 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!!,
+                    promise,
+                    reactContext,
+                )
             } else {
                 promise.resolve(fileUrl)
             }
@@ -41,23 +55,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,7 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
     outputWidth: Int,
     outputHeight: Int,
     bitrate: Int,
+    frameRate: Int,
     listener: CompressionListener,
   ) {
     val uris = mutableListOf<Uri>()
@@ -36,6 +37,7 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
       outputWidth,
       outputHeight,
       bitrate,
+      frameRate,
       listener,
       destPath
     )
@@ -52,6 +54,7 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
     outputWidth: Int,
     outputHeight: Int,
     bitrate: Int,
+    frameRate: Int,
     listener: CompressionListener,
     destPath: String
   ) {
@@ -74,6 +77,7 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
             outputWidth,
             outputHeight,
             bitrate,
+            frameRate,
             listener,
           )
 
@@ -96,6 +100,7 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
     outputWidth: Int,
     outputHeight: Int,
     bitrate: Int,
+    frameRate: Int,
     listener: CompressionListener,
   ): Result = withContext(Dispatchers.Default) {
     return@withContext compressVideo(
@@ -107,6 +112,7 @@ class VideoCompressorClass(private val context: ReactApplicationContext) {
       outputWidth,
       outputHeight,
       bitrate,
+      frameRate,
       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,7 @@ object Compressor {
     outputWidth: Int,
     outputHeight: Int,
     outputBitrate: Int,
+    outputFrameRate: Int,
     listener: CompressionProgressListener,
   ): Result = withContext(Dispatchers.Default) {
 
@@ -123,6 +124,7 @@ object Compressor {
       newHeight!!,
       destination,
       newBitrate,
+      outputFrameRate,
       streamableFile,
       false,
       extractor,
@@ -140,6 +142,7 @@ object Compressor {
     newHeight: Int,
     destination: String,
     newBitrate: Int,
+    outputFrameRate: Int,
     streamableFile: String?,
     disableAudio: Boolean,
     extractor: MediaExtractor,
@@ -178,6 +181,7 @@ object Compressor {
           inputFormat,
           outputFormat,
           newBitrate,
+          outputFrameRate,
         )
 
         val decoder: MediaCodec
@@ -374,7 +378,7 @@ object Compressor {
                         }
           }
 
-        } catch (exception: Exception) {
+        } catch (exception: Throwable) {
           printException(exception)
           return Result(id, success = false, failureMessage = exception.message)
         }
@@ -400,12 +404,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 +429,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

@@ -88,6 +88,16 @@ class VideoCompressorHelper {
             }
             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 +105,34 @@ 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!!,
+                    promise,
+                    reactContext,
+                )
             } catch (ex: Exception) {
                 promise.reject(ex)
             }

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,128 @@ 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
         }
-        if (remeasuredBitrate > maxBitrate) {
-          return maxBitrate;
+
+        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)
+        }
+
+        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 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 profile = createCompressionProfile(track: track, maxSize: CGFloat(maxSize), requestedBitrate: nil)
 
-        let videoBitRate:Int = self.makeVideoBitrate(
-            originalHeight: Int(actualHeight), originalWidth: Int(actualWidth),
-            originalBitrate: Int(bitrate),
-            height: Int(resultHeight), width: Int(resultWidth)
-            );
-
-        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) { progress in
             onProgress(progress)
         } onCompletion: { outputURL in
             onCompletion(outputURL)
@@ -205,36 +278,18 @@ 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 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 videoBitRate = bitRate ?? height*width*1.5
+        let maxSize = (options["maxSize"] as? NSNumber)?.floatValue ?? Float(1920)
+        let profile = createCompressionProfile(track: track, maxSize: CGFloat(maxSize), requestedBitrate: bitRate)
 
-        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) { progress in
             onProgress(progress)
         } onCompletion: { outputURL in
             onCompletion(outputURL)
@@ -243,7 +298,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, onProgress: @escaping (Float) -> Void,  onCompletion: @escaping (URL) -> Void, onFailure: @escaping (Error) -> Void){
         var currentVideoCompression:Int=0
 
         var tmpURL = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
@@ -258,13 +313,15 @@ 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 = [
@@ -284,6 +341,7 @@ class VideoCompressor {
             }
         }, completionHandler: { result in
             currentVideoCompression=0;
+            self.compressorExports[uuid] = nil
             switch exporter.status {
             case .completed:
               onCompletion(exporter.outputURL!)
@@ -293,14 +351,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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-compressor",
-  "version": "1.16.2",
+  "version": "1.17.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",