@honem/native-video-compressor 0.1.0

package/android/src/main/java/com/honem/nativevideocompressor/VideoCompressor.java

@@ -0,0 +1,488 @@
+package com.honem.nativevideocompressor;
+
+import android.content.Context;
+import android.media.MediaCodec;
+import android.media.MediaCodecInfo;
+import android.media.MediaExtractor;
+import android.media.MediaFormat;
+import android.media.MediaMuxer;
+import android.net.Uri;
+import android.os.Build;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileInputStream;
+import java.io.IOException;
+import java.nio.ByteBuffer;
+import java.util.concurrent.atomic.AtomicInteger;
+
+class CompressionResult {
+    String outputPath;
+    long originalSize;
+    long compressedSize;
+}
+
+interface CompressionCallback {
+    void onComplete(CompressionResult result, String error);
+}
+
+public class VideoCompressor {
+    private static final String TAG = "VideoCompressor";
+    private static final int TIMEOUT_USEC = 10000;
+    private static final String COMPRESSED_PREFIX = "compressed_";
+
+    public void compressVideo(
+        Context context,
+        String inputPath,
+        String outputPath,
+        String quality,
+        Integer bitrate,
+        Integer width,
+        Integer height,
+        String format,
+        CompressionCallback callback
+    ) {
+        try {
+            File inputFile = resolveFilePath(context, inputPath);
+            if (inputFile == null || !inputFile.exists()) {
+                callback.onComplete(null, "Input file not found: " + inputPath);
+                return;
+            }
+
+            long originalSize = inputFile.length();
+
+            String outputFormat;
+            if (format != null && !format.isEmpty()) {
+                outputFormat = format;
+            } else {
+                String inputName = inputFile.getName();
+                int lastDot = inputName.lastIndexOf('.');
+                if (lastDot > 0 && lastDot < inputName.length() - 1) {
+                    String inputExtension = inputName.substring(lastDot + 1).toLowerCase();
+                    switch (inputExtension) {
+                        case "mov":
+                            outputFormat = "mov";
+                            break;
+                        case "m4v":
+                            outputFormat = "m4v";
+                            break;
+                        case "3gp":
+                            outputFormat = "3gp";
+                            break;
+                        case "webm":
+                            outputFormat = "webm";
+                            break;
+                        case "mp4":
+                        default:
+                            outputFormat = "mp4";
+                            break;
+                    }
+                } else {
+                    outputFormat = "mp4";
+                }
+            }
+
+            File outputFile;
+            if (outputPath != null) {
+                outputFile = resolveFilePath(context, outputPath);
+            } else {
+                String extension = getFileExtension(outputFormat);
+                String uniqueName = COMPRESSED_PREFIX + System.currentTimeMillis() + "." + extension;
+                File cacheDir = context.getCacheDir();
+                outputFile = new File(cacheDir, uniqueName);
+            }
+
+            MediaExtractor extractor = new MediaExtractor();
+            try {
+                extractor.setDataSource(inputFile.getAbsolutePath());
+
+                int videoTrackIndex = -1;
+                int audioTrackIndex = -1;
+                MediaFormat videoFormat = null;
+                MediaFormat audioFormat = null;
+
+                for (int i = 0; i < extractor.getTrackCount(); i++) {
+                    MediaFormat mediaFormat = extractor.getTrackFormat(i);
+                    String mime = mediaFormat.getString(MediaFormat.KEY_MIME);
+                    if (mime.startsWith("video/") && videoTrackIndex == -1) {
+                        videoTrackIndex = i;
+                        videoFormat = mediaFormat;
+                    } else if (mime.startsWith("audio/") && audioTrackIndex == -1) {
+                        audioTrackIndex = i;
+                        audioFormat = mediaFormat;
+                    }
+                }
+
+                if (videoTrackIndex == -1) {
+                    callback.onComplete(null, "No video track found in input file");
+                    return;
+                }
+
+                // MediaFormat width/height may need to be swapped if rotation is present
+                int originalWidth = videoFormat.getInteger(MediaFormat.KEY_WIDTH);
+                int originalHeight = videoFormat.getInteger(MediaFormat.KEY_HEIGHT);
+                
+                int rotation = 0;
+                if (videoFormat.containsKey(MediaFormat.KEY_ROTATION)) {
+                    rotation = videoFormat.getInteger(MediaFormat.KEY_ROTATION);
+                }
+                
+                if (rotation == 90 || rotation == 270) {
+                    int temp = originalWidth;
+                    originalWidth = originalHeight;
+                    originalHeight = temp;
+                }
+                
+                double originalAspectRatio = (double) originalWidth / originalHeight;
+
+                int[] targetDimensions = calculateTargetDimensions(
+                    originalWidth,
+                    originalHeight,
+                    originalAspectRatio,
+                    quality,
+                    bitrate,
+                    width,
+                    height
+                );
+                
+                int targetWidth = targetDimensions[0];
+                int targetHeight = targetDimensions[1];
+                int targetBitrate = targetDimensions[2];
+
+                int muxerFormat = getMuxerFormat(outputFormat);
+                MediaMuxer muxer = new MediaMuxer(outputFile.getAbsolutePath(), muxerFormat);
+
+                String videoMime = "video/avc"; // H.264
+                MediaFormat outputVideoFormat = MediaFormat.createVideoFormat(videoMime, targetWidth, targetHeight);
+                outputVideoFormat.setInteger(MediaFormat.KEY_COLOR_FORMAT, MediaCodecInfo.CodecCapabilities.COLOR_FormatSurface);
+                outputVideoFormat.setInteger(MediaFormat.KEY_BIT_RATE, targetBitrate);
+                outputVideoFormat.setInteger(MediaFormat.KEY_FRAME_RATE, 30);
+                outputVideoFormat.setInteger(MediaFormat.KEY_I_FRAME_INTERVAL, 1);
+
+                MediaCodec videoEncoder = MediaCodec.createEncoderByType(videoMime);
+                videoEncoder.configure(outputVideoFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+
+                MediaCodec audioEncoder = null;
+                int audioOutputTrackIndex = -1;
+                if (audioTrackIndex != -1 && audioFormat != null) {
+                    String audioMime = audioFormat.getString(MediaFormat.KEY_MIME);
+                    int sampleRate = audioFormat.containsKey(MediaFormat.KEY_SAMPLE_RATE) 
+                        ? audioFormat.getInteger(MediaFormat.KEY_SAMPLE_RATE) : 44100;
+                    int channelCount = audioFormat.containsKey(MediaFormat.KEY_CHANNEL_COUNT)
+                        ? audioFormat.getInteger(MediaFormat.KEY_CHANNEL_COUNT) : 2;
+
+                    MediaFormat outputAudioFormat = MediaFormat.createAudioFormat(audioMime, sampleRate, channelCount);
+                    outputAudioFormat.setInteger(MediaFormat.KEY_BIT_RATE, 128_000);
+                    outputAudioFormat.setInteger(MediaFormat.KEY_AAC_PROFILE, MediaCodecInfo.CodecProfileLevel.AACObjectLC);
+
+                    audioEncoder = MediaCodec.createEncoderByType(audioMime);
+                    audioEncoder.configure(outputAudioFormat, null, null, MediaCodec.CONFIGURE_FLAG_ENCODE);
+                }
+
+                videoEncoder.start();
+                if (audioEncoder != null) {
+                    audioEncoder.start();
+                }
+
+                extractor.selectTrack(videoTrackIndex);
+                extractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
+
+                boolean videoInputEOS = false;
+                boolean videoOutputEOS = false;
+                int videoOutputTrackIndex = -1;
+                long videoStartTime = -1;
+
+                while (!videoOutputEOS) {
+                    if (!videoInputEOS) {
+                        int inputBufferIndex = videoEncoder.dequeueInputBuffer(TIMEOUT_USEC);
+                        if (inputBufferIndex >= 0) {
+                            ByteBuffer inputBuffer = videoEncoder.getInputBuffer(inputBufferIndex);
+                            if (inputBuffer != null) {
+                                int sampleSize = extractor.readSampleData(inputBuffer, 0);
+                                long presentationTimeUs = extractor.getSampleTime();
+
+                                if (sampleSize < 0) {
+                                    videoEncoder.queueInputBuffer(
+                                        inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM
+                                    );
+                                    videoInputEOS = true;
+                                } else {
+                                    videoEncoder.queueInputBuffer(
+                                        inputBufferIndex, 0, sampleSize, presentationTimeUs, 0
+                                    );
+                                    extractor.advance();
+                                }
+                            }
+                        }
+                    }
+
+                    MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+                    int outputBufferIndex = videoEncoder.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
+
+                    if (outputBufferIndex == MediaCodec.INFO_TRY_AGAIN_LATER) {
+                        // No output available yet
+                    } else if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
+                        MediaFormat newFormat = videoEncoder.getOutputFormat();
+                        videoOutputTrackIndex = muxer.addTrack(newFormat);
+                        muxer.start();
+                    } else if (outputBufferIndex >= 0) {
+                        ByteBuffer outputBuffer = videoEncoder.getOutputBuffer(outputBufferIndex);
+
+                        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
+                            bufferInfo.size = 0;
+                        }
+
+                        if (bufferInfo.size != 0) {
+                            if (videoStartTime == -1) {
+                                videoStartTime = bufferInfo.presentationTimeUs;
+                            }
+                            bufferInfo.presentationTimeUs -= videoStartTime;
+
+                            outputBuffer.position(bufferInfo.offset);
+                            outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
+                            muxer.writeSampleData(videoOutputTrackIndex, outputBuffer, bufferInfo);
+                        }
+
+                        videoEncoder.releaseOutputBuffer(outputBufferIndex, false);
+
+                        if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                            videoOutputEOS = true;
+                        }
+                    }
+                }
+
+                if (audioTrackIndex != -1 && audioEncoder != null) {
+                    extractor.selectTrack(audioTrackIndex);
+                    extractor.seekTo(0, MediaExtractor.SEEK_TO_CLOSEST_SYNC);
+
+                    boolean audioInputEOS = false;
+                    boolean audioOutputEOS = false;
+                    long audioStartTime = -1;
+
+                    while (!audioOutputEOS) {
+                        if (!audioInputEOS) {
+                            int inputBufferIndex = audioEncoder.dequeueInputBuffer(TIMEOUT_USEC);
+                            if (inputBufferIndex >= 0) {
+                                ByteBuffer inputBuffer = audioEncoder.getInputBuffer(inputBufferIndex);
+                                if (inputBuffer != null) {
+                                    int sampleSize = extractor.readSampleData(inputBuffer, 0);
+                                    long presentationTimeUs = extractor.getSampleTime();
+
+                                    if (sampleSize < 0) {
+                                        audioEncoder.queueInputBuffer(
+                                            inputBufferIndex, 0, 0, 0, MediaCodec.BUFFER_FLAG_END_OF_STREAM
+                                        );
+                                        audioInputEOS = true;
+                                    } else {
+                                        audioEncoder.queueInputBuffer(
+                                            inputBufferIndex, 0, sampleSize, presentationTimeUs, 0
+                                        );
+                                        extractor.advance();
+                                    }
+                                }
+                            }
+                        }
+
+                        MediaCodec.BufferInfo bufferInfo = new MediaCodec.BufferInfo();
+                        int outputBufferIndex = audioEncoder.dequeueOutputBuffer(bufferInfo, TIMEOUT_USEC);
+
+                        if (outputBufferIndex == MediaCodec.INFO_OUTPUT_FORMAT_CHANGED) {
+                            MediaFormat newFormat = audioEncoder.getOutputFormat();
+                            audioOutputTrackIndex = muxer.addTrack(newFormat);
+                        } else if (outputBufferIndex >= 0) {
+                            ByteBuffer outputBuffer = audioEncoder.getOutputBuffer(outputBufferIndex);
+
+                            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_CODEC_CONFIG) != 0) {
+                                bufferInfo.size = 0;
+                            }
+
+                            if (bufferInfo.size != 0 && audioOutputTrackIndex >= 0) {
+                                if (audioStartTime == -1) {
+                                    audioStartTime = bufferInfo.presentationTimeUs;
+                                }
+                                bufferInfo.presentationTimeUs -= audioStartTime;
+
+                                outputBuffer.position(bufferInfo.offset);
+                                outputBuffer.limit(bufferInfo.offset + bufferInfo.size);
+                                muxer.writeSampleData(audioOutputTrackIndex, outputBuffer, bufferInfo);
+                            }
+
+                            audioEncoder.releaseOutputBuffer(outputBufferIndex, false);
+
+                            if ((bufferInfo.flags & MediaCodec.BUFFER_FLAG_END_OF_STREAM) != 0) {
+                                audioOutputEOS = true;
+                            }
+                        }
+                    }
+                }
+
+                videoEncoder.stop();
+                videoEncoder.release();
+                if (audioEncoder != null) {
+                    audioEncoder.stop();
+                    audioEncoder.release();
+                }
+                muxer.stop();
+                muxer.release();
+                extractor.release();
+
+                long compressedSize = outputFile.length();
+
+                CompressionResult result = new CompressionResult();
+                result.outputPath = outputFile.getAbsolutePath();
+                result.originalSize = originalSize;
+                result.compressedSize = compressedSize;
+
+                callback.onComplete(result, null);
+
+            } catch (Exception e) {
+                Log.e(TAG, "Compression failed", e);
+                callback.onComplete(null, "Compression failed: " + e.getMessage());
+            } finally {
+                extractor.release();
+            }
+
+        } catch (Exception e) {
+            Log.e(TAG, "Error during compression", e);
+            callback.onComplete(null, "Error: " + e.getMessage());
+        }
+    }
+
+    public boolean deleteFile(Context context, String path) {
+        try {
+            File file = resolveFilePath(context, path);
+            if (file != null && file.exists()) {
+                return file.delete();
+            }
+            return false;
+        } catch (Exception e) {
+            Log.e(TAG, "Failed to delete file: " + path, e);
+            return false;
+        }
+    }
+
+    private File resolveFilePath(Context context, String path) {
+        if (path.startsWith("file://")) {
+            return new File(Uri.parse(path).getPath());
+        }
+
+        if (path.startsWith("/")) {
+            return new File(path);
+        }
+
+        // Capacitor file paths: capacitor://localhost/_capacitor_file_/...
+        if (path.contains("_capacitor_file_")) {
+            String[] parts = path.split("_capacitor_file_");
+            if (parts.length > 1) {
+                File filesDir = context.getFilesDir();
+                return new File(filesDir, parts[1]);
+            }
+        }
+
+        File filesDir = context.getFilesDir();
+        return new File(filesDir, path);
+    }
+
+    private String getFileExtension(String format) {
+        switch (format.toLowerCase()) {
+            case "3gp":
+                return "3gp";
+            case "webm":
+                return "webm";
+            case "mp4":
+            default:
+                return "mp4";
+        }
+    }
+
+    private int getMuxerFormat(String format) {
+        switch (format.toLowerCase()) {
+            case "webm":
+                return MediaMuxer.OutputFormat.MUXER_OUTPUT_WEBM;
+            case "3gp":
+                return MediaMuxer.OutputFormat.MUXER_OUTPUT_3GPP;
+            case "mp4":
+            default:
+                return MediaMuxer.OutputFormat.MUXER_OUTPUT_MPEG_4;
+        }
+    }
+
+    /** Returns [targetWidth, targetHeight, targetBitrate] */
+    private int[] calculateTargetDimensions(
+        int originalWidth,
+        int originalHeight,
+        double originalAspectRatio,
+        String quality,
+        Integer bitrate,
+        Integer customWidth,
+        Integer customHeight
+    ) {
+        int targetWidth;
+        int targetHeight;
+        int targetBitrate;
+        Integer maxWidth = null;
+        Integer maxHeight = null;
+
+        switch (quality) {
+            case "low":
+                targetBitrate = 800_000;
+                maxWidth = 854;
+                maxHeight = 480;
+                break;
+            case "high":
+                targetBitrate = bitrate != null ? bitrate : 8_000_000;
+                maxWidth = null;
+                maxHeight = null;
+                break;
+            case "custom":
+                targetBitrate = bitrate != null ? bitrate : 2_000_000;
+                maxWidth = null;
+                maxHeight = null;
+                break;
+            default: // "medium"
+                targetBitrate = 1_500_000;
+                maxWidth = 1280;
+                maxHeight = 720;
+                break;
+        }
+
+        if (customWidth != null && customHeight != null) {
+            targetWidth = customWidth;
+            targetHeight = customHeight;
+            return new int[]{targetWidth, targetHeight, targetBitrate};
+        }
+
+        if (customWidth != null) {
+            int calculatedHeight = (int) (customWidth / originalAspectRatio);
+            targetWidth = Math.min(customWidth, originalWidth);
+            targetHeight = Math.min(calculatedHeight, originalHeight);
+            return new int[]{targetWidth, targetHeight, targetBitrate};
+        }
+
+        if (customHeight != null) {
+            int calculatedWidth = (int) (customHeight * originalAspectRatio);
+            targetWidth = Math.min(calculatedWidth, originalWidth);
+            targetHeight = Math.min(customHeight, originalHeight);
+            return new int[]{targetWidth, targetHeight, targetBitrate};
+        }
+
+        targetWidth = originalWidth;
+        targetHeight = originalHeight;
+
+        if (maxWidth != null && originalWidth > maxWidth) {
+            targetWidth = maxWidth;
+            targetHeight = (int) (maxWidth / originalAspectRatio);
+        }
+
+        if (maxHeight != null && targetHeight > maxHeight) {
+            targetHeight = maxHeight;
+            targetWidth = (int) (maxHeight * originalAspectRatio);
+        }
+
+        targetWidth = Math.min(targetWidth, originalWidth);
+        targetHeight = Math.min(targetHeight, originalHeight);
+
+        return new int[]{targetWidth, targetHeight, targetBitrate};
+    }
+}
+

package/android/src/main/java/com/honem/nativevideocompressor/VideoCompressorPlugin.java

@@ -0,0 +1,72 @@
+package com.honem.nativevideocompressor;
+
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+
+@CapacitorPlugin(name = "VideoCompressor")
+public class VideoCompressorPlugin extends Plugin {
+
+    private final VideoCompressor implementation = new VideoCompressor();
+
+    @PluginMethod
+    public void compressVideo(PluginCall call) {
+        String inputPath = call.getString("inputPath");
+        if (inputPath == null) {
+            call.reject("inputPath is required");
+            return;
+        }
+
+        String outputPath = call.getString("outputPath");
+        String quality = call.getString("quality", "medium");
+        Integer bitrate = call.getInt("bitrate");
+        Integer width = call.getInt("width");
+        Integer height = call.getInt("height");
+        String format = call.getString("format");
+
+        long startTime = System.currentTimeMillis();
+
+        implementation.compressVideo(
+            getContext(),
+            inputPath,
+            outputPath,
+            quality,
+            bitrate,
+            width,
+            height,
+            format,
+            (result, error) -> {
+                if (error != null) {
+                    call.reject(error);
+                    return;
+                }
+
+                long duration = System.currentTimeMillis() - startTime;
+                JSObject response = new JSObject();
+                response.put("outputPath", result.outputPath);
+                response.put("originalSize", result.originalSize);
+                response.put("compressedSize", result.compressedSize);
+                response.put("compressionRatio", (double) result.originalSize / result.compressedSize);
+                response.put("duration", (int) duration);
+                call.resolve(response);
+            }
+        );
+    }
+
+    @PluginMethod
+    public void deleteFile(PluginCall call) {
+        String path = call.getString("path");
+        if (path == null) {
+            call.reject("path is required");
+            return;
+        }
+
+        boolean success = implementation.deleteFile(getContext(), path);
+        JSObject response = new JSObject();
+        response.put("success", success);
+        call.resolve(response);
+    }
+}
+

package/dist/definitions.d.ts

@@ -0,0 +1,76 @@
+export interface CompressionOptions {
+    /**
+     * Path to the input video file
+     */
+    inputPath: string;
+    /**
+     * Optional path for the output file. If not provided, a temp file will be created.
+     */
+    outputPath?: string;
+    /**
+     * Quality preset: 'low', 'medium', 'high', or 'custom'
+     * @default 'medium'
+     */
+    quality?: 'low' | 'medium' | 'high' | 'custom';
+    /**
+     * Video bitrate in bits per second (only used when quality is 'custom')
+     */
+    bitrate?: number;
+    /**
+     * Output video width in pixels (only used when quality is 'custom')
+     */
+    width?: number;
+    /**
+     * Output video height in pixels (only used when quality is 'custom')
+     */
+    height?: number;
+    /**
+     * Output video format
+     * @default 'mp4'
+     */
+    format?: 'mp4' | 'mov' | 'm4v' | '3gp' | 'webm';
+}
+export interface CompressionResult {
+    /**
+     * Path to the compressed video file (temp file if outputPath not provided)
+     */
+    outputPath: string;
+    /**
+     * Original file size in bytes
+     */
+    originalSize: number;
+    /**
+     * Compressed file size in bytes
+     */
+    compressedSize: number;
+    /**
+     * Compression ratio (originalSize / compressedSize)
+     */
+    compressionRatio: number;
+    /**
+     * Duration of the compression process in milliseconds
+     */
+    duration: number;
+}
+export interface DeleteFileOptions {
+    /**
+     * Path to the file to delete
+     */
+    path: string;
+}
+export interface DeleteFileResult {
+    /**
+     * Whether the file was successfully deleted
+     */
+    success: boolean;
+}
+export interface VideoCompressorPlugin {
+    /**
+     * Compress a video file
+     */
+    compressVideo(options: CompressionOptions): Promise<CompressionResult>;
+    /**
+     * Delete a file (typically used to clean up temp compressed files after upload)
+     */
+    deleteFile(options: DeleteFileOptions): Promise<DeleteFileResult>;
+}

package/dist/definitions.js

@@ -0,0 +1 @@
+export {};

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+import type { VideoCompressorPlugin } from './definitions';
+declare const VideoCompressor: VideoCompressorPlugin;
+export * from './definitions';
+export { VideoCompressor };

package/dist/index.js

@@ -0,0 +1,11 @@
+import { registerPlugin } from '@capacitor/core';
+// Register plugin with platform-specific implementations
+// For Electron, the plugin will use the Electron implementation automatically
+// when running in an Electron environment (via Capacitor's plugin bridge)
+const VideoCompressor = registerPlugin('VideoCompressor', {
+    web: () => import('./web').then(m => new m.VideoCompressorWeb()),
+    // Electron implementation extends WebPlugin and works with Capacitor's standard plugin system
+    // It will be automatically used when the plugin is called in an Electron environment
+});
+export * from './definitions';
+export { VideoCompressor };

package/dist/web.d.ts

@@ -0,0 +1,6 @@
+import { WebPlugin } from '@capacitor/core';
+import type { VideoCompressorPlugin, CompressionOptions, CompressionResult, DeleteFileOptions, DeleteFileResult } from './definitions';
+export declare class VideoCompressorWeb extends WebPlugin implements VideoCompressorPlugin {
+    compressVideo(_options: CompressionOptions): Promise<CompressionResult>;
+    deleteFile(_options: DeleteFileOptions): Promise<DeleteFileResult>;
+}

package/dist/web.js

@@ -0,0 +1,9 @@
+import { WebPlugin } from '@capacitor/core';
+export class VideoCompressorWeb extends WebPlugin {
+    async compressVideo(_options) {
+        throw new Error('Video compression is not supported in web browsers. Please use a native platform (iOS, Android, or Electron).');
+    }
+    async deleteFile(_options) {
+        throw new Error('File deletion is not supported in web browsers. Please use a native platform (iOS, Android, or Electron).');
+    }
+}