capacitor-native-video-compressor 1.0.2 → 1.0.4

package/README.md

@@ -1,6 +1,6 @@
 # capacitor-native-video-compressor
 
-Native video compressor using LightCompressor and AVFoundation
+A Capacitor plugin to compress videos natively on iOS (using AVFoundation), Android (using LightCompressor), and Web (using FFmpeg.wasm).
 
 ## Install
 
@@ -9,11 +9,147 @@ npm install capacitor-native-video-compressor
 npx cap sync
 ```
 
+## Supported Platforms
+
+- **iOS**: Uses `AVAssetExportSession` (Hardware accelerated).
+- **Android**: Uses `LightCompressor` (MediaCodec hardware accelerated).
+- **Web**: Uses `@ffmpeg/ffmpeg` (WebAssembly).
+
+## Native Configuration
+
+### iOS
+
+Remember to add the following to your `Info.plist` if you are picking videos from the Photo Library before compressing them:
+
+```xml
+<key>NSPhotoLibraryUsageDescription</key>
+<string>We need access to your photo library to select videos for compression.</string>
+```
+
+### Android
+
+If you are reading videos from external storage, ensure you have the appropriate permissions in your `AndroidManifest.xml`:
+
+```xml
+<uses-permission android:name="android.permission.READ_MEDIA_VIDEO" />
+<uses-permission android:name="android.permission.READ_EXTERNAL_STORAGE" android:maxSdkVersion="32" />
+```
+
+## Web Configuration (Required)
+
+To use video compression on the Web platform, `FFmpeg.wasm` requires `SharedArrayBuffer` to function properly. You must configure your web server/framework to serve these specific HTTP headers:
+
+```http
+Cross-Origin-Embedder-Policy: credentialless
+Cross-Origin-Opener-Policy: same-origin
+```
+
+### Example: Nuxt 3 / Vite
+
+If you are using Vite or Nuxt, update your configuration to include these headers and avoid optimizing the FFmpeg packages:
+
+```typescript
+// nuxt.config.ts or vite.config.ts
+export default defineNuxtConfig({
+  routeRules: {
+    '/**': {
+      headers: {
+        'Cross-Origin-Embedder-Policy': 'credentialless',
+        'Cross-Origin-Opener-Policy': 'same-origin',
+      },
+    },
+  },
+  vite: {
+    server: {
+      headers: {
+        'Cross-Origin-Embedder-Policy': 'credentialless',
+        'Cross-Origin-Opener-Policy': 'same-origin',
+      },
+    },
+    optimizeDeps: {
+      exclude: ['@ffmpeg/ffmpeg', '@ffmpeg/util', 'capacitor-native-video-compressor'],
+    },
+  },
+});
+```
+
+## Usage
+
+### 1. Initialization (Web Only)
+
+Before compressing videos on the Web platform, you **must** initialize the FFmpeg core. This step is safely ignored on Native platforms (iOS/Android), so calling it cross-platform is perfectly fine.
+
+```typescript
+import { NativeVideoCompressor } from 'capacitor-native-video-compressor';
+import { Capacitor } from '@capacitor/core';
+
+const initCompressor = async () => {
+  if (Capacitor.getPlatform() === 'web') {
+    const result = await NativeVideoCompressor.initialize();
+    if (!result.success) {
+      console.error('Failed to load FFmpeg core:', result.message);
+    }
+  }
+};
+```
+
+### 2. Compression & Progress Subscription
+
+Subscribe to the `onProgress` event to get updates on the compression process, and then call `compressVideo()`.
+
+```typescript
+import { NativeVideoCompressor } from 'capacitor-native-video-compressor';
+
+// 1. Add progress listener
+const listener = await NativeVideoCompressor.addListener('onProgress', (info) => {
+  // info.status can be: 'started', 'loading_core', 'progress'
+  if (info.status === 'progress') {
+    console.log(`Compression Progress: ${info.percent}%`);
+  }
+});
+
+// 2. Start Compression
+try {
+  const result = await NativeVideoCompressor.compressVideo({
+    sourcePath: '/path/to/original/video.mp4', // Web: blob URL or file path
+    quality: 'MEDIUM', // 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW'
+  });
+
+  console.log('Compression successful! Saved at:', result.destPath);
+} catch (error) {
+  console.error('Compression failed:', error);
+}
+
+// 3. Remove listener when done
+listener.remove();
+```
+
+### Quality Presets
+
+The `quality` parameter determines the output resolution and compression ratio. Depending on the original aspect ratio, the video will be scaled to match the following heights (or widths, preserving aspect ratio):
+
+| Preset      | Target Resolution | Best For                                  |
+| ----------- | ----------------- | ----------------------------------------- |
+| `VERY_HIGH` | ~ 1080p           | Preserving original high quality          |
+| `HIGH`      | ~ 720p            | Good balance for social media sharing     |
+| `MEDIUM`    | ~ 540p            | Efficient storage and decent quality      |
+| `LOW`       | ~ 480p            | Standard low-bandwidth usage              |
+| `360P`      | ~ 360p            | Very small files                          |
+| `VERY_LOW`  | ~ 240p            | Extreme compression, noticeably pixelated |
+
+> **Note on Web Platform**: On Web, lower qualities also aggressively reduce the Audio Bitrate (down to 48kbps for VERY_LOW) to maximize space savings. On Native, audio maintains steady quality.
+
+### Platform Differences for `sourcePath`
+
+- **iOS/Android**: `sourcePath` must be a physical device file path (e.g., `file:///var/mobile/...` or `content://...`). Do not pass paths obtained from the Capacitor `WebView` (like `http://localhost/...`).
+- **Web**: `sourcePath` can be a Blob URL (e.g., `blob:http://localhost:3000/...`), a base64 Data URI, or a direct link to a file if CORS allows.
+
 ## API
 
 <docgen-index>
 
 * [`compressVideo(...)`](#compressvideo)
+* [`initialize()`](#initialize)
 * [`addListener('onProgress', ...)`](#addlisteneronprogress-)
 * [Interfaces](#interfaces)
 
@@ -37,6 +173,17 @@ compressVideo(options: CompressOptions) => Promise<CompressResult>
 --------------------
 
 
+### initialize()
+
+```typescript
+initialize() => Promise<{ success: boolean; message?: string; }>
+```
+
+**Returns:** <code>Promise&lt;{ success: boolean; message?: string; }&gt;</code>
+
+--------------------
+
+
 ### addListener('onProgress', ...)
 
 ```typescript
@@ -66,11 +213,11 @@ addListener(eventName: 'onProgress', listenerFunc: (info: { status: string; perc
 
 #### CompressOptions
 
-| Prop             | Type                                                                  |
-| ---------------- | --------------------------------------------------------------------- |
-| **`sourcePath`** | <code>string</code>                                                   |
-| **`destPath`**   | <code>string</code>                                                   |
-| **`quality`**    | <code>'VERY_HIGH' \| 'HIGH' \| 'MEDIUM' \| 'LOW' \| 'VERY_LOW'</code> |
+| Prop             | Type                                                                            |
+| ---------------- | ------------------------------------------------------------------------------- |
+| **`sourcePath`** | <code>string</code>                                                             |
+| **`destPath`**   | <code>string</code>                                                             |
+| **`quality`**    | <code>'VERY_HIGH' \| 'HIGH' \| 'MEDIUM' \| 'LOW' \| 'VERY_LOW' \| '360P'</code> |
 
 
 #### PluginListenerHandle

package/android/src/main/java/com/atomic/videocompressor/NativeVideoCompressorPlugin.java

@@ -1,26 +1,23 @@
 package com.atomic.videocompressor;
 
-import android.util.Log;
-
+import android.content.Intent;
 import android.net.Uri;
-import java.util.Collections;
+import android.util.Log;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
 import com.abedelazizshe.lightcompressorlibrary.CompressionListener;
 import com.abedelazizshe.lightcompressorlibrary.VideoCompressor;
 import com.abedelazizshe.lightcompressorlibrary.VideoQuality;
-import com.abedelazizshe.lightcompressorlibrary.config.Configuration;
 import com.abedelazizshe.lightcompressorlibrary.config.AppSpecificStorageConfiguration;
+import com.abedelazizshe.lightcompressorlibrary.config.Configuration;
 import com.getcapacitor.JSObject;
 import com.getcapacitor.Plugin;
 import com.getcapacitor.PluginCall;
 import com.getcapacitor.PluginMethod;
 import com.getcapacitor.annotation.CapacitorPlugin;
-
-import androidx.annotation.NonNull;
-import androidx.annotation.Nullable;
-
 import java.io.File;
 import java.util.Arrays;
-import android.content.Intent;
+import java.util.Collections;
 
 @CapacitorPlugin(name = "NativeVideoCompressor")
 public class NativeVideoCompressorPlugin extends Plugin {
@@ -28,7 +25,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
     @PluginMethod
     public void compressVideo(PluginCall call) {
         String sourcePath = call.getString("sourcePath");
-        
+
         if (sourcePath == null) {
             call.reject("Missing sourcePath");
             return;
@@ -37,7 +34,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
         // 1. Chuẩn bị Uri và Tên file xuất ra
         Uri srcUri;
         String fileName = "compressed_" + System.currentTimeMillis() + ".mp4";
-        
+
         if (sourcePath.startsWith("content://")) {
             srcUri = Uri.parse(sourcePath);
         } else if (sourcePath.startsWith("file://")) {
@@ -48,7 +45,7 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
         // Đọc quality từ Javascript (Mặc định là MEDIUM)
         String qualityString = call.getString("quality", "MEDIUM");
-        
+
         VideoQuality videoQuality = VideoQuality.MEDIUM;
         if (qualityString != null) {
             if (qualityString.equals("360P")) {
@@ -64,19 +61,22 @@ public class NativeVideoCompressorPlugin extends Plugin {
             }
         }
 
-          Log.d("NativeVideoCompressor", "====== VIDEO COMPRESSION QUALITY RECEIVED: " + qualityString + "+ video quality: " + videoQuality + " ======");
+        Log.d(
+            "NativeVideoCompressor",
+            "====== VIDEO COMPRESSION QUALITY RECEIVED: " + qualityString + "+ video quality: " + videoQuality + " ======"
+        );
 
         // 2. Cấu hình thông số nén (Dành riêng cho LightCompressor 1.3.2)
         // Lưu ý: Java phải truyền đủ 9 tham số do thư viện gốc viết bằng Kotlin
         Configuration configuration = new Configuration(
-                videoQuality, // Chất lượng nén
-                false, // tắt tính năng giới hạn Bitrate tối thiểu của file gốc
-                null,  // videoBitrateInMbps (Ép buộc giá trị Bitrate để đảm bảo file luôn nhẹ đi)
-                false, // disableAudio
-                false, // keepOriginalResolution
-                null,  // videoWidth
-                null,  // videoHeight
-                Arrays.asList(fileName) // videoNames
+            videoQuality, // Chất lượng nén
+            false, // tắt tính năng giới hạn Bitrate tối thiểu của file gốc
+            null, // videoBitrateInMbps (Ép buộc giá trị Bitrate để đảm bảo file luôn nhẹ đi)
+            false, // disableAudio
+            false, // keepOriginalResolution
+            null, // videoWidth
+            null, // videoHeight
+            Arrays.asList(fileName) // videoNames
         );
 
         // 3. Cấu hình nơi lưu (Lưu an toàn vào thư mục nội bộ của App)
@@ -96,52 +96,51 @@ public class NativeVideoCompressorPlugin extends Plugin {
 
         // 4. Bắt đầu nén (Đã cập nhật List Uri và int index)
         VideoCompressor.start(
-                getContext(),
-                Collections.singletonList(srcUri), // Nhận vào một List chứa đường dẫn
-                false,                 // isStreamable
-                null,                  // sharedStorageConfiguration (Không dùng)
-                storageConfig,         // Cấu hình lưu trữ
-                configuration,         // Cấu hình chất lượng
-                new CompressionListener() {
-                    
-                      @Override
-                    public void onProgress(int i, float v) {
-                        // Gửi % tiến độ về Javascript để vẽ thanh Progress
-                        JSObject ret = new JSObject();
-                        ret.put("status", "progress");
-                        ret.put("percent", v);
-                        notifyListeners("onProgress", ret);
-                    }
-
-                    @Override
-                    public void onFailure(int i, @NonNull String failureMessage) {
-                        getContext().stopService(serviceIntent);
-                        call.reject("Nén thất bại: " + failureMessage);
-                    }
-
-                    @Override
-                    public void onSuccess(int i, long l, @Nullable String s) {
-                        getContext().stopService(serviceIntent);
-                        // Nén xong, trả kết quả đường dẫn file mới về cho JS
-                        JSObject ret = new JSObject();
-                        ret.put("success", true);
-                        ret.put("destPath", s);
-                        call.resolve(ret);
-                    }
-
-                    @Override
-                    public void onStart(int i) {
-                        JSObject ret = new JSObject();
-                        ret.put("status", "started");
-                        notifyListeners("onProgress", ret);
-                    }
-
-                    @Override
-                    public void onCancelled(int i) {
-                        getContext().stopService(serviceIntent);
-                        call.reject("Đã hủy nén");
-                    }
+            getContext(),
+            Collections.singletonList(srcUri), // Nhận vào một List chứa đường dẫn
+            false, // isStreamable
+            null, // sharedStorageConfiguration (Không dùng)
+            storageConfig, // Cấu hình lưu trữ
+            configuration, // Cấu hình chất lượng
+            new CompressionListener() {
+                @Override
+                public void onProgress(int i, float v) {
+                    // Gửi % tiến độ về Javascript để vẽ thanh Progress
+                    JSObject ret = new JSObject();
+                    ret.put("status", "progress");
+                    ret.put("percent", v);
+                    notifyListeners("onProgress", ret);
+                }
+
+                @Override
+                public void onFailure(int i, @NonNull String failureMessage) {
+                    getContext().stopService(serviceIntent);
+                    call.reject("Nén thất bại: " + failureMessage);
                 }
+
+                @Override
+                public void onSuccess(int i, long l, @Nullable String s) {
+                    getContext().stopService(serviceIntent);
+                    // Nén xong, trả kết quả đường dẫn file mới về cho JS
+                    JSObject ret = new JSObject();
+                    ret.put("success", true);
+                    ret.put("destPath", s);
+                    call.resolve(ret);
+                }
+
+                @Override
+                public void onStart(int i) {
+                    JSObject ret = new JSObject();
+                    ret.put("status", "started");
+                    notifyListeners("onProgress", ret);
+                }
+
+                @Override
+                public void onCancelled(int i) {
+                    getContext().stopService(serviceIntent);
+                    call.reject("Đã hủy nén");
+                }
+            }
         );
     }
-}
+}

package/android/src/main/java/com/atomic/videocompressor/VideoCompressionService.java

@@ -7,7 +7,6 @@ import android.app.Service;
 import android.content.Intent;
 import android.os.Build;
 import android.os.IBinder;
-
 import androidx.annotation.Nullable;
 import androidx.core.app.NotificationCompat;
 
@@ -25,11 +24,11 @@ public class VideoCompressionService extends Service {
     @Override
     public int onStartCommand(Intent intent, int flags, int startId) {
         Notification notification = new NotificationCompat.Builder(this, CHANNEL_ID)
-                .setContentTitle("Đang nén video")
-                .setContentText("Tiến trình đang chạy ngầm...")
-                .setSmallIcon(android.R.drawable.ic_popup_sync)
-                .setPriority(NotificationCompat.PRIORITY_LOW)
-                .build();
+            .setContentTitle("Đang nén video")
+            .setContentText("Tiến trình đang chạy ngầm...")
+            .setSmallIcon(android.R.drawable.ic_popup_sync)
+            .setPriority(NotificationCompat.PRIORITY_LOW)
+            .build();
 
         // Check for Android 14+ specific foreground service typing requirements if compiled against API 34+
         // In this case, we rely on the manifest declaration for dataSync.
@@ -51,9 +50,9 @@ public class VideoCompressionService extends Service {
     private void createNotificationChannel() {
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             NotificationChannel serviceChannel = new NotificationChannel(
-                    CHANNEL_ID,
-                    "Video Compression Service Channel",
-                    NotificationManager.IMPORTANCE_LOW
+                CHANNEL_ID,
+                "Video Compression Service Channel",
+                NotificationManager.IMPORTANCE_LOW
             );
             NotificationManager manager = getSystemService(NotificationManager.class);
             if (manager != null) {

package/dist/docs.json

@@ -24,6 +24,16 @@
         ],
         "slug": "compressvideo"
       },
+      {
+        "name": "initialize",
+        "signature": "() => Promise<{ success: boolean; message?: string; }>",
+        "parameters": [],
+        "returns": "Promise<{ success: boolean; message?: string | undefined; }>",
+        "tags": [],
+        "docs": "",
+        "complexTypes": [],
+        "slug": "initialize"
+      },
       {
         "name": "addListener",
         "signature": "(eventName: 'onProgress', listenerFunc: (info: { status: string; percent?: number; }) => void) => Promise<PluginListenerHandle>",
@@ -100,7 +110,7 @@
           "tags": [],
           "docs": "",
           "complexTypes": [],
-          "type": "'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | undefined"
+          "type": "'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P' | undefined"
         }
       ]
     },

package/dist/esm/definitions.d.ts

@@ -2,7 +2,7 @@ import type { PluginListenerHandle } from '@capacitor/core';
 export interface CompressOptions {
     sourcePath: string;
     destPath?: string;
-    quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW';
+    quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P';
 }
 export interface CompressResult {
     success: boolean;
@@ -10,6 +10,10 @@ export interface CompressResult {
 }
 export interface NativeVideoCompressorPlugin {
     compressVideo(options: CompressOptions): Promise<CompressResult>;
+    initialize(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
     addListener(eventName: 'onProgress', listenerFunc: (info: {
         status: string;
         percent?: number;

package/dist/esm/definitions.js.map

@@ -1 +1 @@
-{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\nexport interface CompressOptions {\n  sourcePath: string;\n  destPath?: string;\n  quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW';\n}\n\nexport interface CompressResult {\n  success: boolean;\n  destPath: string;\n}\n\nexport interface NativeVideoCompressorPlugin {\n  compressVideo(options: CompressOptions): Promise<CompressResult>;\n\n  // Đã sửa lại chuẩn cho Capacitor mới nhất (chỉ trả về Promise)\n  addListener(\n    eventName: 'onProgress',\n    listenerFunc: (info: { status: string; percent?: number }) => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"","sourcesContent":["import type { PluginListenerHandle } from '@capacitor/core';\n\nexport interface CompressOptions {\n  sourcePath: string;\n  destPath?: string;\n  quality?: 'VERY_HIGH' | 'HIGH' | 'MEDIUM' | 'LOW' | 'VERY_LOW' | '360P';\n}\n\nexport interface CompressResult {\n  success: boolean;\n  destPath: string;\n}\n\nexport interface NativeVideoCompressorPlugin {\n  compressVideo(options: CompressOptions): Promise<CompressResult>;\n\n  initialize(): Promise<{ success: boolean; message?: string }>;\n\n  // Đã sửa lại chuẩn cho Capacitor mới nhất (chỉ trả về Promise)\n  addListener(\n    eventName: 'onProgress',\n    listenerFunc: (info: { status: string; percent?: number }) => void,\n  ): Promise<PluginListenerHandle>;\n}\n"]}

package/dist/esm/web.d.ts

@@ -1,5 +1,12 @@
 import { WebPlugin } from '@capacitor/core';
 import type { NativeVideoCompressorPlugin, CompressOptions, CompressResult } from './definitions';
 export declare class NativeVideoCompressorWeb extends WebPlugin implements NativeVideoCompressorPlugin {
+    private ffmpeg;
+    private isLoaded;
+    private loadFFmpeg;
+    initialize(): Promise<{
+        success: boolean;
+        message?: string;
+    }>;
     compressVideo(options: CompressOptions): Promise<CompressResult>;
 }

package/dist/esm/web.js

@@ -1,14 +1,166 @@
 import { WebPlugin } from '@capacitor/core';
+import { FFmpeg } from '@ffmpeg/ffmpeg';
+import { fetchFile, toBlobURL } from '@ffmpeg/util';
 export class NativeVideoCompressorWeb extends WebPlugin {
+    constructor() {
+        super(...arguments);
+        this.ffmpeg = null;
+        this.isLoaded = false;
+    }
+    async loadFFmpeg() {
+        if (this.isLoaded && this.ffmpeg)
+            return;
+        this.notifyListeners('onProgress', { status: 'loading_core', percent: 0 });
+        try {
+            this.ffmpeg = new FFmpeg();
+            // Listen to FFmpeg progress and map it to capacitor plugin events
+            this.ffmpeg.on('progress', ({ progress }) => {
+                // progress is a fraction between 0 and 1
+                this.notifyListeners('onProgress', { status: 'progress', percent: Math.round(progress * 100) });
+            });
+            this.ffmpeg.on('log', ({ message }) => {
+                console.log('[FFmpeg Log]', message);
+            });
+            // Use standard single-threaded version for best compatibility across browsers
+            // without requiring complex SharedArrayBuffer headers configuration
+            const baseURL = 'https://unpkg.com/@ffmpeg/core@0.12.6/dist/esm';
+            console.log('Starting to load FFmpeg core from:', baseURL);
+            await this.ffmpeg.load({
+                coreURL: await toBlobURL(`${baseURL}/ffmpeg-core.js`, 'text/javascript'),
+                wasmURL: await toBlobURL(`${baseURL}/ffmpeg-core.wasm`, 'application/wasm'),
+            });
+            this.isLoaded = true;
+            console.log('FFmpeg core loaded successfully');
+        }
+        catch (e) {
+            console.error('Failed to load FFmpeg:', e);
+            throw e;
+        }
+    }
+    async initialize() {
+        try {
+            if (this.isLoaded) {
+                return { success: true, message: 'Already initialized' };
+            }
+            await this.loadFFmpeg();
+            return { success: true, message: 'Initialization successful' };
+        }
+        catch (e) {
+            return { success: false, message: e.message || 'Initialization failed' };
+        }
+    }
     async compressVideo(options) {
-        console.warn('Tính năng nén video bằng GPU không hỗ trợ trên trình duyệt Web.', options);
-        // Báo lỗi cho chuẩn Capacitor báo rằng nền tảng này không được hỗ trợ
-        throw this.unimplemented('Not implemented on web.');
-        // (Hoặc nếu bạn không muốn văng lỗi trên web, bạn có thể trả về luôn đường dẫn gốc)
-        // return {
-        //   success: false,
-        //   destPath: options.sourcePath
-        // };
+        try {
+            if (!this.isLoaded) {
+                await this.loadFFmpeg();
+            }
+            if (!this.ffmpeg) {
+                throw new Error('FFmpeg failed to load');
+            }
+            this.notifyListeners('onProgress', { status: 'started', percent: 0 });
+            const { sourcePath, quality = 'MEDIUM' } = options;
+            const inputFileName = 'input.mp4';
+            const outputFileName = 'output.mp4';
+            // Map quality to CRF, Scale, and Audio Bitrate
+            let crf = '28';
+            let scale = ''; // default keep resolution
+            let audioBitrate = '128k';
+            switch (quality) {
+                case 'VERY_HIGH': // 1080p
+                    crf = '23';
+                    scale = '-vf scale=-2:1080';
+                    audioBitrate = '128k';
+                    break;
+                case 'HIGH': // 720p
+                    crf = '28';
+                    scale = '-vf scale=-2:720';
+                    audioBitrate = '128k';
+                    break;
+                case 'MEDIUM': // 540p
+                    crf = '30';
+                    scale = '-vf scale=-2:540';
+                    audioBitrate = '96k';
+                    break;
+                case 'LOW': // 480p
+                    crf = '32';
+                    scale = '-vf scale=-2:480';
+                    audioBitrate = '96k';
+                    break;
+                case '360P': // 360p
+                    crf = '28';
+                    scale = '-vf scale=-2:360';
+                    audioBitrate = '64k';
+                    break;
+                case 'VERY_LOW': // 240p
+                    crf = '35';
+                    scale = '-vf scale=-2:240';
+                    audioBitrate = '48k';
+                    break;
+            }
+            console.log('[FFmpeg] Fetching source file...', sourcePath);
+            let inputData;
+            try {
+                inputData = await fetchFile(sourcePath);
+            }
+            catch (err) {
+                console.error('[FFmpeg] Error fetching source file:', err);
+                throw new Error('Could not fetch source video file');
+            }
+            console.log('[FFmpeg] Writing file to FS...', inputData.byteLength, 'bytes');
+            try {
+                await this.ffmpeg.writeFile(inputFileName, inputData);
+            }
+            catch (err) {
+                console.error('[FFmpeg] Error writing to FS:', err);
+                throw new Error('Could not write to FFmpeg FS');
+            }
+            // Construct FFmpeg command array
+            const args = ['-i', inputFileName];
+            // Video codec and compression parameters (superfast provides much better size than ultrafast)
+            args.push('-c:v', 'libx264', '-preset', 'superfast', '-crf', crf);
+            // Resize if needed (split by space)
+            if (scale) {
+                args.push(...scale.split(' '));
+            }
+            // Audio re-encoding to save space
+            args.push('-c:a', 'aac', '-b:a', audioBitrate);
+            // Output
+            args.push(outputFileName);
+            console.log('[FFmpeg] Executing command:', args.join(' '));
+            try {
+                const retCode = await this.ffmpeg.exec(args);
+                console.log('[FFmpeg] Exec returned code:', retCode);
+            }
+            catch (err) {
+                console.error('[FFmpeg] Error executing command:', err);
+                throw new Error('FFmpeg execution failed');
+            }
+            console.log('[FFmpeg] Reading output file...');
+            let data;
+            try {
+                data = await this.ffmpeg.readFile(outputFileName);
+            }
+            catch (err) {
+                console.error('[FFmpeg] Error reading output file:', err);
+                throw new Error('Could not read FFmpeg output');
+            }
+            // Free memory
+            await this.ffmpeg.deleteFile(inputFileName);
+            await this.ffmpeg.deleteFile(outputFileName);
+            console.log('[FFmpeg] Creating Blob URL from output...', data.byteLength, 'bytes');
+            // Create a blob URL for the resulting file
+            const blob = new Blob([data], { type: 'video/mp4' });
+            const destPath = URL.createObjectURL(blob);
+            console.log('[FFmpeg] Compression complete, returning path:', destPath);
+            return {
+                success: true,
+                destPath: destPath,
+            };
+        }
+        catch (error) {
+            console.error('[FFmpeg] Compression process failed:', error);
+            throw error;
+        }
     }
 }
 //# sourceMappingURL=web.js.map