react-native-video-trim 2.2.11 → 3.0.1

package/README.md

@@ -8,7 +8,7 @@
 
 ## Features
 - ✅ Support video and audio
-- ✅ Support local and remote files
+- ✅ Support local files
 - ✅ Save to Photos, Documents and Share to other apps
 - ✅ Check if file is valid video/audio
 - ✅ File operations: list, clean up, delete specific file
@@ -42,13 +42,6 @@ npx pod-install ios
 
 ## Usage
 
-> [!IMPORTANT]  
-> Note that for both Android and iOS you have to try on real device
-
-> [!IMPORTANT]  
-> If you plan to trim remote file, you must install FFMPEG version from "https" onwards, "min" version won't work. See bottom to know how to install specific FFMPEG version
-
-
 ```js
 import { showEditor } from 'react-native-video-trim';
 
@@ -233,6 +226,7 @@ Main method to show Video Editor UI.
   - `alertOnFailTitle` (`default = "Error"`)
   - `alertOnFailMessage` (`default = "Fail to load media. Possibly invalid file or no network connection"`)
   - `alertOnFailCloseText` (`default = "Close"`)
+  - `progressUpdateInterval` (`default = 0.1`): how fast the trimming progress update interval is, default is emit progress every 100ms (0.1 second)
 
 If `saveToPhoto = true`, you must ensure that you have request permission to write to photo/gallery
 - For Android: you need to have `<uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />` in AndroidManifest.xml
@@ -349,25 +343,6 @@ showEditor(url, {
 })
 ```
 
-You must install FFMPEG version from "https" onwards, "min" version won't work. Eg.
-```gradle
-// Android: android/build.gradle > buildscript > ext
-
-buildscript {
-    ext {
-        ffmpegKitPackage = "full"
-    }
-
----
-// iOS:
-
-FFMPEGKIT_PACKAGE=https npx pod-install ios
-
-// or
-
-FFMPEGKIT_PACKAGE=https pod install
-```
-
 # Cancel trimming
 <div align="left">
 <img src="images/progress.jpg" width="200" />
@@ -385,85 +360,6 @@ If there's error while loading media, there'll be a prompt
 
 Related props: `alertOnFailToLoad, alertOnFailTitle, alertOnFailMessage, alertOnFailCloseText`
 
-# Customize FFMPEG version
-This library uses FFMPEG-Kit Android under the hood, by default FFMPEG `min` is used, which gives smallest bundle size. To customize the package version please see below
-
-## Android
-If you ever need to use other version of FFMPEG-Kit for Android, you can do the following, in your `android/build.gradle` > `buildscript` > `ext`:
-
-```gradle
-buildscript {
-    ext {
-        ffmpegKitPackage = "full" // default "min"
-
-        ffmpegKitPackageVersion = "5.1.LTS" // default 6.0-2
-    }
-```
-
-## iOS
-Same as Android, there're 2 environment variables respectively you can use to specify FFMPEG Kit version you want to use: `FFMPEG_KIT_PACKAGE` and `FFMPEG_KIT_PACKAGE_VERSION`.
-
-You need to pass the variables when running pod install. Eg:
-```shell
-# override package name, default: min
-FFMPEGKIT_PACKAGE=full npx pod-install ios
-
-# override package version, default: '~> 6.0
-FFMPEGKIT_PACKAGE_VERSION=5.1 npx pod-install ios
-
-# or both
-FFMPEGKIT_PACKAGE=full FFMPEGKIT_PACKAGE_VERSION=5.1 npx pod-install ios
-```
-
-## Packages
-
-<table>
-<thead>
-<tr>
-<th align="center"></th>
-<th align="center"><sup>min</sup></th>
-<th align="center"><sup>min-gpl</sup></th>
-<th align="center"><sup>https</sup></th>
-<th align="center"><sup>https-gpl</sup></th>
-<th align="center"><sup>audio</sup></th>
-<th align="center"><sup>video</sup></th>
-<th align="center"><sup>full</sup></th>
-<th align="center"><sup>full-gpl</sup></th>
-</tr>
-</thead>
-<tbody>
-<tr>
-<td align="center"><sup>external libraries</sup></td>
-<td align="center">-</td>
-<td align="center"><sup>vid.stab</sup><br><sup>x264</sup><br><sup>x265</sup><br><sup>xvidcore</sup></td>
-<td align="center"><sup>gmp</sup><br><sup>gnutls</sup></td>
-<td align="center"><sup>gmp</sup><br><sup>gnutls</sup><br><sup>vid.stab</sup><br><sup>x264</sup><br><sup>x265</sup><br><sup>xvidcore</sup></td>
-<td align="center"><sup>lame</sup><br><sup>libilbc</sup><br><sup>libvorbis</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>shine</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>twolame</sup><br><sup>vo-amrwbenc</sup></td>
-<td align="center"><sup>dav1d</sup><br><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>kvazaar</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libtheora</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>snappy</sup><br><sup>zimg</sup></td>
-<td align="center"><sup>dav1d</sup><br><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>gmp</sup><br><sup>gnutls</sup><br><sup>kvazaar</sup><br><sup>lame</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libilbc</sup><br><sup>libtheora</sup><br><sup>libvorbis</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>libxml2</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>shine</sup><br><sup>snappy</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>twolame</sup><br><sup>vo-amrwbenc</sup><br><sup>zimg</sup></td>
-<td align="center"><sup>dav1d</sup><br><sup>fontconfig</sup><br><sup>freetype</sup><br><sup>fribidi</sup><br><sup>gmp</sup><br><sup>gnutls</sup><br><sup>kvazaar</sup><br><sup>lame</sup><br><sup>libass</sup><br><sup>libiconv</sup><br><sup>libilbc</sup><br><sup>libtheora</sup><br><sup>libvorbis</sup><br><sup>libvpx</sup><br><sup>libwebp</sup><br><sup>libxml2</sup><br><sup>opencore-amr</sup><br><sup>opus</sup><br><sup>shine</sup><br><sup>snappy</sup><br><sup>soxr</sup><br><sup>speex</sup><br><sup>twolame</sup><br><sup>vid.stab</sup><br><sup>vo-amrwbenc</sup><br><sup>x264</sup><br><sup>x265</sup><br><sup>xvidcore</sup><br><sup>zimg</sup></td>
-</tr>
-<tr>
-<td align="center"><sup>android system libraries</sup></td>
-<td align="center" colspan=8><sup>zlib</sup><br><sup>MediaCodec</sup></td>
-</tr>
-<tr>
-<td align="center"><sup>ios system libraries</sup></td>
-<td align="center" colspan=8><sup>bzip2</sup><br><sup>AudioToolbox</sup><br><sup>AVFoundation</sup><br><sup>iconv</sup><br><sup>VideoToolbox</sup><br><sup>zlib</sup></td>
-</tr>
-<tr>
-<tr>
-<td align="center"><sup>macos system libraries</sup></td>
-<td align="center" colspan=8><sup>bzip2</sup><br><sup>AudioToolbox</sup><br><sup>AVFoundation</sup><br><sup>Core Image</sup><br><sup>iconv</sup><br><sup>OpenCL</sup><br><sup>OpenGL</sup><br><sup>VideoToolbox</sup><br><sup>zlib</sup></td>
-</tr>
-<tr>
-<td align="center"><sup>tvos system libraries</sup></td>
-<td align="center" colspan=8><sup>bzip2</sup><br><sup>AudioToolbox</sup><br><sup>iconv</sup><br><sup>VideoToolbox</sup><br><sup>zlib</sup></td>
-</tr>
-</tbody>
-</table>
-
-
 # Android: update SDK version
 You can override sdk version to use any version in your `android/build.gradle` > `buildscript` > `ext`
 ```gradle
@@ -476,20 +372,6 @@ buildscript {
 }
 ```
 
-# Naming conflict with `ffmpeg-kit-react-native`
-This issue is due to this package and `ffmpeg-kit-react-native` have same ffmpegkit class name under the hood:
-
-<img src="images/error_conflict_name.png"/>
-
-To fix it we need to synchronize the FFMPEG Kit version of the 2 packages. For example: as shown in the image above, `ffmpeg-kit-react-native` uses `https`, version `6.0`, hence we need to run this:
-```
-FFMPEGKIT_PACKAGE=https FFMPEG_KIT_PACKAGE_VERSION=6.0 pod install
-```
-
-Another way to find out exactly FFMPEG Kit version that `ffmpeg-kit-react-native` using is to ([check here for package name](https://github.com/arthenica/ffmpeg-kit/blob/main/react-native/ffmpeg-kit-react-native.podspec#L19)) and package version is `version` in [package.json](https://github.com/arthenica/ffmpeg-kit/blob/main/react-native/package.json#L3)
-
-When you know the package name + version, simply run `pod install` with `FFMPEGKIT_PACKAGE` and `FFMPEG_KIT_PACKAGE_VERSION` like above
-
 # Thanks
 - Android part is created by modified + fix bugs from: https://github.com/iknow4/Android-Video-Trimmer
 - iOS UI is created from: https://github.com/AndreasVerhoeven/VideoTrimmerControl

package/android/build.gradle

@@ -43,16 +43,6 @@ def supportsNamespace() {
   return major >= 8
 }
 
-def safePackageName() {
-  def name = project.properties['ffmpegKit.android.package.name']
-  name + '-' + safeExtGet('ffmpegKitPackage', 'min')
-}
-
-def safePackageVersion() {
-  def name = project.properties['ffmpegKit.android.package.version']
-  safeExtGet('ffmpegKitPackageVersion', name)
-}
-
 def safeExtGet(String prop, String fallback) {
   rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
 }
@@ -104,7 +94,6 @@ dependencies {
   //noinspection GradleDynamicVersion
   implementation "com.facebook.react:react-native:+"
   implementation 'androidx.recyclerview:recyclerview:1.3.1'
-  implementation safePackageName() + ':' + safePackageVersion()
 }
 
 if (isNewArchitectureEnabled()) {

package/android/gradle.properties

@@ -3,5 +3,3 @@ VideoTrim_minSdkVersion=21
 VideoTrim_targetSdkVersion=31
 VideoTrim_compileSdkVersion=31
 VideoTrim_ndkversion=21.4.7075529
-ffmpegKit.android.package.name=com.arthenica:ffmpeg-kit
-ffmpegKit.android.package.version=6.0-2

package/android/src/main/java/com/videotrim/VideoTrimModule.java

@@ -99,6 +99,7 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
   private boolean openShareSheetOnFinish = false;
   private boolean isVideoType = true;
   private boolean closeWhenFinish = true;
+  private float progressUpdateInterval = 0.1f;
 
   private static final int REQUEST_CODE_SAVE_FILE = 1;
 
@@ -194,6 +195,7 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     isVideoType = !config.hasKey("type") || !Objects.equals(config.getString("type"), "audio");
 
     closeWhenFinish = !config.hasKey("closeWhenFinish") || config.getBoolean("closeWhenFinish");
+    progressUpdateInterval = config.hasKey("progressUpdateInterval") ? (float) config.getDouble("progressUpdateInterval") : 0.1f;
 
     Activity activity = getReactApplicationContext().getCurrentActivity();
 
@@ -372,11 +374,6 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
     alertDialog.show();
   }
 
-  @Override
-  public void onLog(WritableMap log) {
-    sendEvent(getReactApplicationContext(), "onLog", log);
-  }
-
   @Override
   public void onStatistics(WritableMap statistics) {
     sendEvent(getReactApplicationContext(), "onStatistics", statistics);
@@ -468,7 +465,7 @@ public class VideoTrimModule extends ReactContextBaseJavaModule implements Video
 
     mProgressDialog.setOnShowListener(dialog -> {
       sendEvent(getReactApplicationContext(), "onStartTrimming", null);
-      trimmerView.onSaveClicked();
+      trimmerView.onSaveClicked(progressUpdateInterval);
     });
 
     mProgressDialog.show();

package/android/src/main/java/com/videotrim/interfaces/VideoTrimListener.java

@@ -11,6 +11,5 @@ public interface VideoTrimListener {
   void onError(String errorMessage, ErrorCode errorCode);
   void onCancel();
   void onSave();
-  void onLog(WritableMap log);
   void onStatistics(WritableMap statistics);
 }

package/android/src/main/java/com/videotrim/utils/VideoTrimmerUtil.java

@@ -1,12 +1,10 @@
 package com.videotrim.utils;
 
 import android.annotation.SuppressLint;
+import android.content.Context;
 import android.graphics.Bitmap;
+import android.media.MediaCodec;
 import android.media.MediaMetadataRetriever;
-import com.arthenica.ffmpegkit.FFmpegKit;
-import com.arthenica.ffmpegkit.FFmpegSession;
-import com.arthenica.ffmpegkit.ReturnCode;
-import com.arthenica.ffmpegkit.SessionState;
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 import com.videotrim.enums.ErrorCode;
@@ -21,6 +19,14 @@ import iknow.android.utils.UnitConverter;
 import iknow.android.utils.callback.SingleCallback;
 import iknow.android.utils.thread.BackgroundExecutor;
 
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.media.MediaMuxer;
+import android.os.Handler;
+import android.os.Looper;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+
 public class VideoTrimmerUtil {
 
   private static final String TAG = VideoTrimmerUtil.class.getSimpleName();
@@ -40,77 +46,164 @@ public class VideoTrimmerUtil {
   public static final int THUMB_WIDTH = UnitConverter.dpToPx(25); // x2 for better resolution
   private static final int THUMB_RESOLUTION_RES = 2; // double thumb resolution for better quality
 
-  public static FFmpegSession trim(String inputFile, String outputFile, int videoDuration, long startMs, long endMs, final VideoTrimListener callback) {
-    // Get the current date and time
-    Date currentDate = new Date();
+  private static final int BUFFER_SIZE = 1024 * 1024; // 1MB buffer
 
-    // Create a SimpleDateFormat object with the desired format
-    @SuppressLint("SimpleDateFormat") SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
+  // Custom session class to manage trimming and cancellation
+  public static class TrimSession {
+    private final Thread trimThread;
+    private volatile boolean isCancelled = false;
 
-    // Set the timezone to UTC
-    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+    private TrimSession(Thread thread) {
+      this.trimThread = thread;
+    }
 
-    // Format the current date and time
-    String formattedDateTime = dateFormat.format(currentDate);
-
-    String[] cmds = {
-      "-ss",
-      startMs + "ms",
-      "-to",
-      endMs + "ms",
-      "-i",
-      inputFile,
-      "-c",
-      "copy",
-      "-metadata",
-      "creation_time=" + formattedDateTime,
-      outputFile
-    };
-    System.out.println("Command: " + String.join(",", cmds));
-
-    return FFmpegKit.executeWithArgumentsAsync(cmds, session -> {
-      SessionState state = session.getState();
-      ReturnCode returnCode = session.getReturnCode();
-      if (ReturnCode.isSuccess(session.getReturnCode())) {
-        // SUCCESS
-        callback.onFinishTrim(outputFile, startMs, endMs, videoDuration);
-      } else if (ReturnCode.isCancel(session.getReturnCode())) {
-        // CANCEL
-        callback.onCancelTrim();
-      } else {
-        // FAILURE
-        String errorMessage = String.format("Command failed with state %s and rc %s.%s", state, returnCode, session.getFailStackTrace());
-        callback.onError(errorMessage, ErrorCode.TRIMMING_FAILED);
-      }
-    }, log -> {
-      System.out.println("FFmpeg process started with log " + log.getMessage());
-
-      WritableMap map = Arguments.createMap();
-      map.putInt("level", log.getLevel().getValue());
-      map.putString("message", log.getMessage());
-      map.putDouble("sessionId", log.getSessionId());
-      map.putString("logStr", log.toString());
-      callback.onLog(map);
-    }, statistics -> {
-      int timeInMilliseconds = (int) statistics.getTime();
-      if (timeInMilliseconds > 0) {
-        int completePercentage =
-          (timeInMilliseconds * 100) / videoDuration;
-        callback.onTrimmingProgress(Math.min(Math.max(completePercentage, 0), 100));
+    public void cancel() {
+      isCancelled = true;
+      if (trimThread != null) {
+        trimThread.interrupt();
       }
+    }
 
-      WritableMap map = Arguments.createMap();
-      map.putDouble("sessionId", statistics.getSessionId());
-      map.putInt("videoFrameNumber", statistics.getVideoFrameNumber());
-      map.putDouble("videoFps", statistics.getVideoFps());
-      map.putDouble("videoQuality", statistics.getVideoQuality());
-      map.putDouble("size", statistics.getSize());
-      map.putDouble("time", statistics.getTime());
-      map.putDouble("bitrate", statistics.getBitrate());
-      map.putDouble("speed", statistics.getSpeed());
-      map.putString("statisticsStr", statistics.toString());
-      callback.onStatistics(map);
+    public boolean isCancelled() {
+      return !isCancelled;
+    }
+  }
+
+  public static TrimSession trim(String inputFile, String outputFile, int videoDuration, long startMs, long endMs, final VideoTrimListener callback, float progressUpdateInterval, MediaMetadataRetriever retriever) {
+    // Format creation time
+    @SuppressLint("SimpleDateFormat") SimpleDateFormat dateFormat = new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ");
+    dateFormat.setTimeZone(TimeZone.getTimeZone("UTC"));
+    String formattedDateTime = dateFormat.format(new Date());
+
+    // Start trimming in a background thread
+    Thread trimThread = new Thread(() -> {
+      MediaExtractor extractor = null;
+      MediaMuxer muxer = null;
+//      Handler mainHandler = new Handler(Looper.getMainLooper());
+      TrimSession session = new TrimSession(Thread.currentThread());
+
+      try {
+        // Get rotation metadata from input file
+        retriever.setDataSource(inputFile);
+        String rotationStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
+        int rotation = rotationStr != null ? Integer.parseInt(rotationStr) : 0;
+        retriever.release();
+
+        extractor = new MediaExtractor();
+        extractor.setDataSource(inputFile);
+
+        int trackCount = extractor.getTrackCount();
+        muxer = new MediaMuxer(outputFile, MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4);
+        int[] trackIndices = new int[trackCount];
+        long[] trackStartTimes = new long[trackCount];
+        boolean[] tracksAdded = new boolean[trackCount];
+
+        // Select tracks and add to muxer
+        for (int i = 0; i < trackCount; i++) {
+          MediaFormat format = extractor.getTrackFormat(i);
+          trackIndices[i] = muxer.addTrack(format);
+          tracksAdded[i] = false;
+          extractor.selectTrack(i);
+        }
+
+        // Set rotation metadata on muxer
+        muxer.setOrientationHint(rotation);
+
+        // Seek to start time
+        long startUs = startMs * 1000; // Convert ms to μs
+        long endUs = endMs * 1000;
+        extractor.seekTo(startUs, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
+
+        ByteBuffer buffer = ByteBuffer.allocate(BUFFER_SIZE);
+        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+        long lastProgressTime = System.currentTimeMillis();
+
+        muxer.start();
+        while (session.isCancelled()) {
+          bufferInfo.size = extractor.readSampleData(buffer, 0);
+          if (bufferInfo.size < 0) break; // EOS
+
+          long sampleTime = extractor.getSampleTime();
+          if (sampleTime > endUs) break;
+
+          bufferInfo.presentationTimeUs = sampleTime;
+          // Map MediaExtractor flags to MediaCodec flags
+          int extractorFlags = extractor.getSampleFlags();
+          bufferInfo.flags = (extractorFlags & MediaExtractor.SAMPLE_FLAG_SYNC) != 0 ? MediaCodec.BUFFER_FLAG_KEY_FRAME : 0;
+          int trackIndex = extractor.getSampleTrackIndex();
+
+          if (!tracksAdded[trackIndex]) {
+            trackStartTimes[trackIndex] = sampleTime;
+            tracksAdded[trackIndex] = true;
+          }
+          bufferInfo.presentationTimeUs -= trackStartTimes[trackIndex]; // Adjust time to start at 0
+
+          muxer.writeSampleData(trackIndices[trackIndex], buffer, bufferInfo);
+          extractor.advance();
+
+          // Progress update (every progressUpdateInterval * 1000 ms)
+          long currentTime = System.currentTimeMillis();
+          if (currentTime - lastProgressTime >= progressUpdateInterval * 1000) {
+            double progress = (double)(sampleTime - startUs) / (endUs - startUs);
+            if (progress > 0 && progress <= 1) {
+              WritableMap statsMap = Arguments.createMap();
+              statsMap.putDouble("time", progress * videoDuration);
+              statsMap.putDouble("progress", progress); // Percentage
+
+              callback.onStatistics(statsMap);
+              callback.onTrimmingProgress((int)(progress * 100));
+
+//              mainHandler.post(() -> callback.onStatistics(statsMap));
+//              mainHandler.post(() -> callback.onTrimmingProgress((int)(progress * 100)));
+
+            }
+            lastProgressTime = currentTime;
+          }
+        }
+
+        if (session.isCancelled()) {
+          muxer.stop();
+
+          // Update creation_time via MediaStore
+//          android.content.ContentResolver contentResolver = context.getContentResolver();
+//          android.net.Uri uri = android.provider.MediaStore.Files.getContentUri("external");
+//          android.content.ContentValues values = new android.content.ContentValues();
+//          values.put(android.provider.MediaStore.MediaColumns.DATA, outputFile);
+//          values.put(android.provider.MediaStore.MediaColumns.DATE_ADDED, System.currentTimeMillis() / 1000);
+//          values.put(android.provider.MediaStore.MediaColumns.DATE_MODIFIED, System.currentTimeMillis() / 1000);
+//          values.put(android.provider.MediaStore.MediaColumns.DATE_TAKEN, System.currentTimeMillis());
+//          contentResolver.insert(uri, values);
+//          android.content.ContentValues updateValues = new android.content.ContentValues();
+//          updateValues.put(android.provider.MediaStore.MediaColumns.DATE_TAKEN, System.currentTimeMillis());
+//          contentResolver.update(uri, updateValues, android.provider.MediaStore.MediaColumns.DATA + "=?", new String[]{outputFile});
+
+//          mainHandler.post(() -> callback.onFinishTrim(outputFile, startMs, endMs, videoDuration));
+          callback.onFinishTrim(outputFile, startMs, endMs, videoDuration);
+        } else {
+//          mainHandler.post(callback::onCancelTrim);
+          callback.onCancelTrim();
+        }
+
+      } catch (IOException e) {
+        e.printStackTrace();
+//        mainHandler.post(() -> callback.onError("Trimming failed: " + e.getMessage(), ErrorCode.TRIMMING_FAILED));
+        callback.onError("Trimming failed: " + e.getMessage(), ErrorCode.TRIMMING_FAILED);
+      } finally {
+        try {
+          if (muxer != null) {
+            if (session.isCancelled()) muxer.release();
+          }
+          if (extractor != null) extractor.release();
+        } catch (Exception e) {
+          e.printStackTrace();
+          System.err.println("Error releasing resources: " + e.getMessage());
+        }
+      }
     });
+
+    TrimSession session = new TrimSession(trimThread);
+    trimThread.start();
+    return session;
   }
 
   public static void shootVideoThumbInBackground(final MediaMetadataRetriever mediaMetadataRetriever, final int totalThumbsCount, final long startPosition,

package/android/src/main/java/com/videotrim/widgets/VideoTrimmerView.java

@@ -32,7 +32,6 @@ import android.widget.VideoView;
 
 import androidx.appcompat.app.AlertDialog;
 
-import com.arthenica.ffmpegkit.FFmpegSession;
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReadableMap;
 import com.videotrim.R;
@@ -109,7 +108,7 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
   private long jumpToPositionOnLoad = 0;
   private FrameLayout headerView;
   private TextView headerText;
-  private FFmpegSession ffmpegSession;
+  private VideoTrimmerUtil.TrimSession trimSession;
   private boolean alertOnFailToLoad = true;
   private String alertOnFailTitle = "Error";
   private String alertOnFailMessage = "Fail to load media. Possibly invalid file or no network connection";
@@ -366,20 +365,23 @@ public class VideoTrimmerView extends FrameLayout implements IVideoTrimmerView {
     setHandleTouchListener(trailingHandle, false);
   }
 
-  public void onSaveClicked() {
+  public void onSaveClicked(float progressUpdateInterval) {
     onMediaPause();
-    ffmpegSession = VideoTrimmerUtil.trim(
+    trimSession = VideoTrimmerUtil.trim(
       mSourceUri.toString(),
       StorageUtil.getOutputPath(mContext, mOutputExt),
       mDuration,
       startTime,
       endTime,
-      mOnTrimVideoListener);
+      mOnTrimVideoListener,
+      progressUpdateInterval,
+      mediaMetadataRetriever
+    );
   }
 
   public void onCancelTrimClicked() {
-    if (ffmpegSession != null) {
-      ffmpegSession.cancel();
+    if (trimSession != null) {
+      trimSession.cancel();
     } else {
       mOnTrimVideoListener.onCancelTrim();
     }