react-native-video-trim 3.0.2 → 3.0.4

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

@@ -1,7 +1,5 @@
 package com.videotrim.utils;
 
-import android.annotation.SuppressLint;
-import android.content.Context;
 import android.graphics.Bitmap;
 import android.media.MediaCodec;
 import android.media.MediaMetadataRetriever;
@@ -9,21 +7,13 @@ import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.WritableMap;
 import com.videotrim.enums.ErrorCode;
 import com.videotrim.interfaces.VideoTrimListener;
-
-import java.text.SimpleDateFormat;
-import java.util.Date;
-import java.util.TimeZone;
-
 import iknow.android.utils.DeviceUtil;
 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;
 
@@ -64,36 +54,25 @@ public class VideoTrimmerUtil {
       }
     }
 
-    public boolean isCancelled() {
+    public boolean isActive() {
       return !isCancelled;
     }
   }
 
   public static TrimSession trim(String inputFile, String outputFile, int videoDuration, long startMs, long endMs, final VideoTrimListener callback, float progressUpdateInterval) {
-    // 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
-        MediaMetadataRetriever retriever = MediaMetadataUtil.getMediaMetadataRetriever(inputFile);
-
-        int rotation = 0;
-        if (retriever != null) {
-          retriever.setDataSource(inputFile);
-          String rotationStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION);
-          rotation = rotationStr != null ? Integer.parseInt(rotationStr) : 0;
-          retriever.release();
-        }
-
+        MediaMetadataRetriever retriever = new MediaMetadataRetriever();
+        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);
@@ -103,10 +82,45 @@ public class VideoTrimmerUtil {
         int[] trackIndices = new int[trackCount];
         long[] trackStartTimes = new long[trackCount];
         boolean[] tracksAdded = new boolean[trackCount];
-
-        // Select tracks and add to muxer
+        int videoTrackIndex = -1;
+
+        // Calculate trimmed duration
+        long startUs = startMs * 1000; // e.g., 5s = 5000000us
+        long endUs = endMs * 1000;     // e.g., 9s = 9000000us
+        long trimmedDurationUs = endUs - startUs; // e.g., 4s = 4000000us
+
+        // Determine max buffer size from video format and resolution
+        int maxBufferSize = BUFFER_SIZE; // Default 1MB
+        String widthStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH);
+        String heightStr = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT);
+        int width = widthStr != null ? Integer.parseInt(widthStr) : 0; // Default to unknown
+        int height = heightStr != null ? Integer.parseInt(heightStr) : 0;
+
+        // Adjust buffer size based on resolution
+        if (width > 3840 || height > 2160) { // 8K+
+          maxBufferSize = 16 * 1024 * 1024; // 16MB for 8K
+        } else if (width > 1920 || height > 1080) { // 4K
+          maxBufferSize = 8 * 1024 * 1024; // 8MB for 4K
+        } else if (width > 1280 || height > 720) { // 1080p
+          maxBufferSize = 4 * 1024 * 1024; // 4MB for 1080p
+        } // 720p or lower (or unknown resolution) sticks with BUFFER_SIZE (1MB)
+
+        // Add tracks with corrected duration
         for (int i = 0; i < trackCount; i++) {
           MediaFormat format = extractor.getTrackFormat(i);
+
+          // Override with KEY_MAX_INPUT_SIZE if available
+          if (format.containsKey(MediaFormat.KEY_MAX_INPUT_SIZE)) {
+            int maxInputSize = format.getInteger(MediaFormat.KEY_MAX_INPUT_SIZE);
+            maxBufferSize = Math.max(maxBufferSize, maxInputSize);
+          }
+
+          String mime = format.getString(MediaFormat.KEY_MIME);
+          if (mime != null && mime.startsWith("video/")) {
+            videoTrackIndex = i;
+          }
+          // Set the duration for each track to the trimmed duration
+          format.setLong(MediaFormat.KEY_DURATION, trimmedDurationUs);
           trackIndices[i] = muxer.addTrack(format);
           tracksAdded[i] = false;
           extractor.selectTrack(i);
@@ -116,16 +130,15 @@ public class VideoTrimmerUtil {
         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);
+        ByteBuffer buffer = ByteBuffer.allocate(maxBufferSize);
         MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
         long lastProgressTime = System.currentTimeMillis();
+        boolean videoSampleWritten = false;
 
         muxer.start();
-        while (session.isCancelled()) {
+        while (session.isActive()) {
           bufferInfo.size = extractor.readSampleData(buffer, 0);
           if (bufferInfo.size < 0) break; // EOS
 
@@ -133,7 +146,6 @@ public class VideoTrimmerUtil {
           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();
@@ -144,10 +156,18 @@ public class VideoTrimmerUtil {
           }
           bufferInfo.presentationTimeUs -= trackStartTimes[trackIndex]; // Adjust time to start at 0
 
+          // Ensure presentation time doesn't exceed trimmed duration
+          if (bufferInfo.presentationTimeUs >= trimmedDurationUs) {
+            extractor.advance();
+            continue;
+          }
+
+          if (trackIndex == videoTrackIndex) {
+            videoSampleWritten = true;
+          }
           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);
@@ -158,46 +178,44 @@ public class VideoTrimmerUtil {
 
               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();
+        // For static videos: ensure one video frame if none written
+        if (!videoSampleWritten && videoTrackIndex != -1) {
+          for (int i = 0; i < trackCount; i++) {
+            if (i != videoTrackIndex) {
+              extractor.unselectTrack(i);
+            }
+          }
+          extractor.selectTrack(videoTrackIndex);
+          extractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
+          bufferInfo.size = extractor.readSampleData(buffer, 0);
+          if (bufferInfo.size >= 0) {
+            bufferInfo.presentationTimeUs = 0;
+            // Map MediaExtractor flags to MediaCodec flags
+            int extractorFlags = extractor.getSampleFlags();
+            bufferInfo.flags = (extractorFlags & MediaExtractor.SAMPLE_FLAG_SYNC) != 0 ? MediaCodec.BUFFER_FLAG_KEY_FRAME : 0;
+            muxer.writeSampleData(trackIndices[videoTrackIndex], buffer, bufferInfo);
+          }
+        }
 
-          // 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));
+        if (session.isActive()) {
+          muxer.stop();
           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 (muxer != null && session.isActive()) {
+            muxer.release();
           }
           if (extractor != null) extractor.release();
         } catch (Exception e) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-video-trim",
-  "version": "3.0.2",
+  "version": "3.0.4",
   "description": "Video trimmer for your React Native app",
   "main": "lib/commonjs/index",
   "module": "lib/module/index",