@honem/native-video-compressor 0.1.0

package/electron/README.md

@@ -0,0 +1,53 @@
+# Electron Implementation
+
+This directory contains the Electron-specific implementation of the video compressor plugin.
+
+## Setup
+
+To use this plugin in an Electron app, you need to:
+
+1. Install the required dependencies:
+```bash
+npm install fluent-ffmpeg @ffmpeg-installer/ffmpeg
+```
+
+2. Register the plugin in your Electron main process:
+
+The plugin uses Capacitor's standard plugin registration. In your Electron main process, you can register it manually if needed:
+
+```typescript
+import { VideoCompressorElectron } from '@honem/native-video-compressor/electron';
+import { Capacitor } from '@capacitor/core';
+
+// Register the Electron implementation
+if (Capacitor.getPlatform() === 'electron') {
+  // The plugin will be automatically registered when imported
+  // If you need manual registration, you can do:
+  const compressor = new VideoCompressorElectron();
+  // Register with Capacitor's bridge if needed
+}
+```
+
+Alternatively, you can use the plugin directly in your renderer process:
+
+```typescript
+import { VideoCompressor } from '@honem/native-video-compressor';
+
+// The plugin will automatically use the Electron implementation
+// when running in an Electron environment
+const result = await VideoCompressor.compressVideo({
+  inputPath: '/path/to/video.mp4',
+  quality: 'medium'
+});
+```
+
+**Note**: The plugin automatically detects the Electron platform and uses the appropriate implementation. No additional registration is typically required.
+
+## FFmpeg
+
+The Electron implementation uses FFmpeg for video compression. It will:
+1. First try to use the bundled FFmpeg from `@ffmpeg-installer/ffmpeg`
+2. Fall back to system FFmpeg if available in PATH
+
+Make sure FFmpeg is available either via the npm package or installed on the system.
+

package/electron/src/index.ts

@@ -0,0 +1,4 @@
+// Electron plugin registration
+// This file is used when the plugin is loaded in an Electron environment
+export { VideoCompressorElectron } from './video-compressor';
+

package/electron/src/video-compressor.ts

@@ -0,0 +1,202 @@
+import type { VideoCompressorPlugin, CompressionOptions, CompressionResult, DeleteFileOptions, DeleteFileResult } from '../../src/definitions';
+import { WebPlugin } from '@capacitor/core';
+import * as ffmpeg from 'fluent-ffmpeg';
+import * as ffmpegInstaller from '@ffmpeg-installer/ffmpeg';
+import * as path from 'path';
+import * as fs from 'fs';
+import * as os from 'os';
+import { promisify } from 'util';
+
+const stat = promisify(fs.stat);
+const unlink = promisify(fs.unlink);
+
+let ffmpegPath: string | null = null;
+
+try {
+  ffmpegPath = ffmpegInstaller.path;
+  ffmpeg.setFfmpegPath(ffmpegPath);
+} catch {
+  try {
+    ffmpegPath = 'ffmpeg';
+  } catch {
+    console.warn('FFmpeg not found. Please install FFmpeg or use @ffmpeg-installer/ffmpeg');
+  }
+}
+
+export class VideoCompressorElectron extends WebPlugin implements VideoCompressorPlugin {
+  constructor() {
+    super();
+  }
+
+  async compressVideo(options: CompressionOptions): Promise<CompressionResult> {
+    if (!ffmpegPath) {
+      throw new Error('FFmpeg is not available. Please install FFmpeg or use @ffmpeg-installer/ffmpeg');
+    }
+
+    const startTime = Date.now();
+    const inputPath = this.resolveFilePath(options.inputPath);
+    const outputPath = options.outputPath 
+      ? this.resolveFilePath(options.outputPath)
+      : this.generateTempOutputPath(options.format || 'mp4');
+
+    try {
+      await stat(inputPath);
+    } catch {
+      throw new Error(`Input file not found: ${inputPath}`);
+    }
+
+    const inputStats = await stat(inputPath);
+    const originalSize = inputStats.size;
+
+    const { targetBitrate, targetWidth, targetHeight, videoCodec, audioCodec, format } = 
+      this.getCompressionParams(options);
+
+    try {
+      await stat(outputPath);
+      await unlink(outputPath);
+    } catch {
+      // File doesn't exist, which is fine
+    }
+
+    return new Promise((resolve, reject) => {
+      const command = ffmpeg(inputPath)
+        .videoCodec(videoCodec)
+        .audioCodec(audioCodec)
+        .outputOptions([
+          '-preset fast',
+          '-movflags +faststart',
+        ]);
+
+      if (targetBitrate) {
+        command.videoBitrate(targetBitrate);
+      }
+
+      if (targetWidth && targetHeight) {
+        command.size(`${targetWidth}x${targetHeight}`);
+      }
+
+      command.format(format);
+      command.output(outputPath);
+
+      command.on('error', (error) => {
+        reject(new Error(`FFmpeg error: ${error.message}`));
+      });
+
+      command.on('end', async () => {
+        try {
+          const outputStats = await stat(outputPath);
+          const compressedSize = outputStats.size;
+          const duration = Date.now() - startTime;
+          const compressionRatio = originalSize / compressedSize;
+
+          resolve({
+            outputPath,
+            originalSize,
+            compressedSize,
+            compressionRatio,
+            duration,
+          });
+        } catch (error) {
+          reject(new Error(`Failed to get output file stats: ${error}`));
+        }
+      });
+
+      command.run();
+    });
+  }
+
+  async deleteFile(options: DeleteFileOptions): Promise<DeleteFileResult> {
+    try {
+      const filePath = this.resolveFilePath(options.path);
+      await stat(filePath);
+      await unlink(filePath);
+      return { success: true };
+    } catch {
+      return { success: false };
+    }
+  }
+
+  private resolveFilePath(filePath: string): string {
+    if (filePath.startsWith('file://')) {
+      return filePath.replace('file://', '');
+    }
+
+    if (path.isAbsolute(filePath)) {
+      return filePath;
+    }
+
+    return path.resolve(process.cwd(), filePath);
+  }
+
+  private generateTempOutputPath(format: string): string {
+    const tempDir = os.tmpdir();
+    const extension = this.getFileExtension(format);
+    const uniqueName = `compressed_${Date.now()}.${extension}`;
+    return path.join(tempDir, uniqueName);
+  }
+
+  private getFileExtension(format: string): string {
+    switch (format.toLowerCase()) {
+      case 'mov':
+        return 'mov';
+      case 'm4v':
+        return 'm4v';
+      case 'webm':
+        return 'webm';
+      case '3gp':
+        return '3gp';
+      case 'mp4':
+      default:
+        return 'mp4';
+    }
+  }
+
+  private getCompressionParams(options: CompressionOptions) {
+    let targetBitrate: number | undefined;
+    let targetWidth: number | undefined;
+    let targetHeight: number | undefined;
+    let videoCodec = 'libx264';
+    let audioCodec = 'aac';
+    const format = options.format || 'mp4';
+
+    switch (options.quality) {
+      case 'low':
+        targetBitrate = 800;
+        targetWidth = 854;
+        targetHeight = 480;
+        break;
+      case 'high':
+        targetBitrate = options.bitrate ? options.bitrate / 1000 : 8000;
+        targetWidth = options.width;
+        targetHeight = options.height;
+        break;
+      case 'custom':
+        targetBitrate = options.bitrate ? options.bitrate / 1000 : 2000;
+        targetWidth = options.width;
+        targetHeight = options.height;
+        break;
+      default: // 'medium'
+        targetBitrate = 1500;
+        targetWidth = 1280;
+        targetHeight = 720;
+        break;
+    }
+
+    if (format === 'webm') {
+      videoCodec = 'libvpx-vp9';
+      audioCodec = 'libopus';
+    } else if (format === '3gp') {
+      videoCodec = 'h263';
+      audioCodec = 'amr_nb';
+    }
+
+    return {
+      targetBitrate,
+      targetWidth,
+      targetHeight,
+      videoCodec,
+      audioCodec,
+      format,
+    };
+  }
+}

package/ios/Plugin/Plugin.m

@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+#import <Capacitor/Capacitor.h>
+
+CAP_PLUGIN(VideoCompressorPlugin, "VideoCompressor",
+           CAP_PLUGIN_METHOD(compressVideo, CAPPluginReturnPromise);
+           CAP_PLUGIN_METHOD(deleteFile, CAPPluginReturnPromise);
+)

package/ios/Plugin/VideoCompressor.swift

@@ -0,0 +1,378 @@
+import Foundation
+import AVFoundation
+import UIKit
+
+enum CompressionError: Error {
+    case invalidInputPath
+    case invalidOutputPath
+    case assetLoadFailed
+    case exportSessionCreationFailed
+    case exportFailed(String)
+    case fileNotFound
+    case unsupportedFormat
+}
+
+enum CompressionResult {
+    case success(outputPath: String, originalSize: Int64, compressedSize: Int64)
+    case failure(Error)
+}
+
+class VideoCompressor {
+    
+    private let compressedPrefix = "compressed_"
+    
+    func compressVideo(
+        inputPath: String,
+        outputPath: String?,
+        quality: String,
+        bitrate: Int?,
+        width: Int?,
+        height: Int?,
+        format: String?,
+        completion: @escaping (CompressionResult) -> Void
+    ) {
+        guard let inputURL = resolveFilePath(inputPath) else {
+            completion(.failure(CompressionError.invalidInputPath))
+            return
+        }
+        
+        guard FileManager.default.fileExists(atPath: inputURL.path) else {
+            completion(.failure(CompressionError.fileNotFound))
+            return
+        }
+        
+        let originalSize: Int64
+        do {
+            let attributes = try FileManager.default.attributesOfItem(atPath: inputURL.path)
+            originalSize = attributes[.size] as? Int64 ?? 0
+        } catch {
+            completion(.failure(error))
+            return
+        }
+        
+        let asset = AVAsset(url: inputURL)
+        
+        let outputFormat: String
+        if let format = format, !format.isEmpty {
+            outputFormat = format
+        } else {
+            let inputExtension = inputURL.pathExtension.lowercased()
+            switch inputExtension {
+            case "mov":
+                outputFormat = "mov"
+            case "m4v":
+                outputFormat = "m4v"
+            case "mp4":
+                outputFormat = "mp4"
+            default:
+                outputFormat = "mp4"
+            }
+        }
+        
+        let outputURL: URL
+        if let outputPath = outputPath, let resolvedOutputURL = resolveFilePath(outputPath) {
+            outputURL = resolvedOutputURL
+        } else {
+            let tempDir = FileManager.default.temporaryDirectory
+            let fileExtension = getFileExtension(for: outputFormat)
+            let uniqueName = "\(compressedPrefix)\(Int(Date().timeIntervalSince1970 * 1000)).\(fileExtension)"
+            outputURL = tempDir.appendingPathComponent(uniqueName)
+        }
+        
+        guard let videoTrack = asset.tracks(withMediaType: .video).first else {
+            completion(.failure(CompressionError.assetLoadFailed))
+            return
+        }
+        
+        // naturalSize doesn't account for transform (rotation), calculate actual displayed size
+        let naturalSize = videoTrack.naturalSize
+        let preferredTransform = videoTrack.preferredTransform
+        let rect = CGRect(origin: .zero, size: naturalSize)
+        let transformedRect = rect.applying(preferredTransform)
+        let actualSize = CGSize(width: abs(transformedRect.width), height: abs(transformedRect.height))
+        
+        let originalWidth = Int(actualSize.width)
+        let originalHeight = Int(actualSize.height)
+        let originalAspectRatio = Double(originalWidth) / Double(originalHeight)
+        
+        func calculateTargetDimensions(
+            originalWidth: Int,
+            originalHeight: Int,
+            maxWidth: Int?,
+            maxHeight: Int?,
+            customWidth: Int?,
+            customHeight: Int?
+        ) -> (width: Int, height: Int) {
+            if let cw = customWidth, let ch = customHeight {
+                return (width: cw, height: ch)
+            }
+            
+            if let cw = customWidth {
+                let calculatedHeight = Int(Double(cw) / originalAspectRatio)
+                return (width: min(cw, originalWidth), height: min(calculatedHeight, originalHeight))
+            }
+            
+            if let ch = customHeight {
+                let calculatedWidth = Int(Double(ch) * originalAspectRatio)
+                return (width: min(calculatedWidth, originalWidth), height: min(ch, originalHeight))
+            }
+            
+            var targetWidth = originalWidth
+            var targetHeight = originalHeight
+            
+            if let maxW = maxWidth, originalWidth > maxW {
+                targetWidth = maxW
+                targetHeight = Int(Double(maxW) / originalAspectRatio)
+            }
+            
+            if let maxH = maxHeight, targetHeight > maxH {
+                targetHeight = maxH
+                targetWidth = Int(Double(maxH) * originalAspectRatio)
+            }
+            
+            return (width: min(targetWidth, originalWidth), height: min(targetHeight, originalHeight))
+        }
+        
+        let exportPreset: String
+        let targetBitrate: Int
+        let targetDimensions: (width: Int, height: Int)
+        
+        switch quality {
+        case "low":
+            exportPreset = AVAssetExportPresetLowQuality
+            targetBitrate = 800_000
+            targetDimensions = calculateTargetDimensions(
+                originalWidth: originalWidth,
+                originalHeight: originalHeight,
+                maxWidth: 854,
+                maxHeight: 480,
+                customWidth: width,
+                customHeight: height
+            )
+            
+        case "high":
+            exportPreset = AVAssetExportPresetHighestQuality
+            targetBitrate = 8_000_000
+            targetDimensions = calculateTargetDimensions(
+                originalWidth: originalWidth,
+                originalHeight: originalHeight,
+                maxWidth: nil,
+                maxHeight: nil,
+                customWidth: width,
+                customHeight: height
+            )
+            
+        case "custom":
+            exportPreset = AVAssetExportPresetMediumQuality
+            targetBitrate = bitrate ?? 2_000_000
+            targetDimensions = calculateTargetDimensions(
+                originalWidth: originalWidth,
+                originalHeight: originalHeight,
+                maxWidth: nil,
+                maxHeight: nil,
+                customWidth: width,
+                customHeight: height
+            )
+            
+        default: // "medium"
+            // AVAssetExportSession preset controls bitrate, not targetBitrate variable
+            exportPreset = AVAssetExportPresetMediumQuality
+            targetBitrate = 1_500_000
+            targetDimensions = calculateTargetDimensions(
+                originalWidth: originalWidth,
+                originalHeight: originalHeight,
+                maxWidth: 1280,
+                maxHeight: 720,
+                customWidth: width,
+                customHeight: height
+            )
+        }
+        
+        let targetWidth = targetDimensions.width
+        let targetHeight = targetDimensions.height
+        
+        let composition = AVMutableComposition()
+        
+        guard let compositionVideoTrack = composition.addMutableTrack(
+            withMediaType: .video,
+            preferredTrackID: kCMPersistentTrackID_Invalid
+        ) else {
+            completion(.failure(CompressionError.exportSessionCreationFailed))
+            return
+        }
+        
+        do {
+            try compositionVideoTrack.insertTimeRange(
+                CMTimeRange(start: .zero, duration: asset.duration),
+                of: videoTrack,
+                at: .zero
+            )
+        } catch {
+            completion(.failure(error))
+            return
+        }
+        
+        compositionVideoTrack.preferredTransform = videoTrack.preferredTransform
+        
+        if let audioTrack = asset.tracks(withMediaType: .audio).first {
+            if let compositionAudioTrack = composition.addMutableTrack(
+                withMediaType: .audio,
+                preferredTrackID: kCMPersistentTrackID_Invalid
+            ) {
+                do {
+                    try compositionAudioTrack.insertTimeRange(
+                        CMTimeRange(start: .zero, duration: asset.duration),
+                        of: audioTrack,
+                        at: .zero
+                    )
+                } catch {
+                    print("Warning: Failed to copy audio track: \(error)")
+                }
+            }
+        }
+        
+        let videoComposition = AVMutableVideoComposition()
+        videoComposition.renderSize = CGSize(width: targetWidth, height: targetHeight)
+        videoComposition.frameDuration = CMTime(value: 1, timescale: 30)
+        
+        let instruction = AVMutableVideoCompositionInstruction()
+        instruction.timeRange = CMTimeRange(start: .zero, duration: asset.duration)
+        
+        let layerInstruction = AVMutableVideoCompositionLayerInstruction(assetTrack: compositionVideoTrack)
+        
+        // Transform calculation: rotation → scale → center
+        let compositionNaturalSize = compositionVideoTrack.naturalSize
+        let compositionTransform = compositionVideoTrack.preferredTransform
+        let compositionRect = CGRect(origin: .zero, size: compositionNaturalSize)
+        let transformedCompositionRect = compositionRect.applying(compositionTransform)
+        let compositionDisplaySize = CGSize(width: abs(transformedCompositionRect.width), height: abs(transformedCompositionRect.height))
+        
+        let scaleX = Double(targetWidth) / Double(compositionDisplaySize.width)
+        let scaleY = Double(targetHeight) / Double(compositionDisplaySize.height)
+        let scale = min(scaleX, scaleY)
+        
+        var finalTransform = compositionTransform
+        finalTransform = finalTransform.scaledBy(x: CGFloat(scale), y: CGFloat(scale))
+        
+        let scaledWidth = compositionDisplaySize.width * CGFloat(scale)
+        let scaledHeight = compositionDisplaySize.height * CGFloat(scale)
+        let offsetX = (CGFloat(targetWidth) - scaledWidth) / 2.0
+        let offsetY = (CGFloat(targetHeight) - scaledHeight) / 2.0
+        finalTransform = finalTransform.translatedBy(x: offsetX, y: offsetY)
+        
+        layerInstruction.setTransform(finalTransform, at: .zero)
+        
+        instruction.layerInstructions = [layerInstruction]
+        videoComposition.instructions = [instruction]
+        
+        let finalAsset: AVAsset = composition
+        
+        guard let exportSession = AVAssetExportSession(asset: finalAsset, presetName: exportPreset) else {
+            completion(.failure(CompressionError.exportSessionCreationFailed))
+            return
+        }
+        
+        exportSession.outputURL = outputURL
+        exportSession.outputFileType = getAVFileType(for: outputFormat)
+        exportSession.shouldOptimizeForNetworkUse = true
+        exportSession.videoComposition = videoComposition
+        
+        exportSession.exportAsynchronously {
+            switch exportSession.status {
+            case .completed:
+                let compressedSize: Int64
+                do {
+                    let attributes = try FileManager.default.attributesOfItem(atPath: outputURL.path)
+                    compressedSize = attributes[.size] as? Int64 ?? 0
+                } catch {
+                    completion(.failure(error))
+                    return
+                }
+                
+                completion(.success(
+                    outputPath: outputURL.path,
+                    originalSize: originalSize,
+                    compressedSize: compressedSize
+                ))
+                
+            case .failed:
+                let error = exportSession.error ?? CompressionError.exportFailed("Unknown export error")
+                completion(.failure(error))
+                
+            case .cancelled:
+                completion(.failure(CompressionError.exportFailed("Export was cancelled")))
+                
+            default:
+                completion(.failure(CompressionError.exportFailed("Export failed with status: \(exportSession.status.rawValue)")))
+            }
+        }
+    }
+    
+    func deleteFile(_ path: String) -> Bool {
+        guard let url = resolveFilePath(path) else {
+            return false
+        }
+        
+        do {
+            if FileManager.default.fileExists(atPath: url.path) {
+                try FileManager.default.removeItem(at: url)
+                return true
+            }
+            return false
+        } catch {
+            print("Failed to delete file: \(error)")
+            return false
+        }
+    }
+    
+    private func resolveFilePath(_ path: String) -> URL? {
+        if path.hasPrefix("file://") {
+            return URL(string: path)
+        }
+        
+        if path.hasPrefix("/") {
+            return URL(fileURLWithPath: path)
+        }
+        
+        // Capacitor file paths: capacitor://localhost/_capacitor_file_/...
+        if path.contains("_capacitor_file_") {
+            let fileManager = FileManager.default
+            let documentsPath = fileManager.urls(for: .documentDirectory, in: .userDomainMask)[0]
+            let pathComponents = path.components(separatedBy: "_capacitor_file_")
+            if pathComponents.count > 1 {
+                let relativePath = pathComponents[1]
+                return documentsPath.appendingPathComponent(relativePath)
+            }
+        }
+        
+        let fileManager = FileManager.default
+        let documentsPath = fileManager.urls(for: .documentDirectory, in: .userDomainMask)[0]
+        return documentsPath.appendingPathComponent(path)
+    }
+    
+    private func getFileExtension(for format: String) -> String {
+        switch format.lowercased() {
+        case "mov":
+            return "mov"
+        case "m4v":
+            return "m4v"
+        case "mp4":
+            return "mp4"
+        default:
+            return "mp4"
+        }
+    }
+    
+    private func getAVFileType(for format: String) -> AVFileType {
+        switch format.lowercased() {
+        case "mov":
+            return .mov
+        case "m4v":
+            return .m4v
+        case "mp4":
+            return .mp4
+        default:
+            return .mp4
+        }
+    }
+}