capacitor-native-video-compressor 1.2.0 → 2.1.0

package/dist/plugin.js

@@ -7,40 +7,186 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
      * retry prompt — and tell it apart from a genuine compression failure.
      */
     const CANCELLED = 'CANCELLED';
+    /**
+     * `code` on the error `compressVideo` rejects with on web when WebCodecs can't
+     * encode the video and it is larger than 200 MB, the cap for the ffmpeg.wasm
+     * fallback. ffmpeg.wasm copies the whole input into wasm memory (~2 GB
+     * ceiling), so a large file there crashes or hangs the tab rather than failing
+     * cleanly.
+     */
+    const TOO_LARGE_FOR_WEB = 'TOO_LARGE_FOR_WEB';
+    /**
+     * `code` on the error `compressVideo` rejects with on web when the browser
+     * refuses to store more of the output (storage quota). Retryable once space
+     * is freed.
+     */
+    const STORAGE_FULL = 'STORAGE_FULL';
 
     const NativeVideoCompressor = core.registerPlugin('NativeVideoCompressor', {
         web: () => Promise.resolve().then(function () { return web; }).then((m) => new m.NativeVideoCompressorWeb()),
     });
 
     /**
-     * Rejection shape for a cancelled compress. `code` matches what `call.reject`
+     * WebCodecs output goes to the origin private file system so a long video
+     * never sits whole in memory. The File handed back stays readable only while
+     * its OPFS entry exists, and callers keep it well past `compressVideo` (until
+     * the upload is done, or longer for a retry), so a successful output stays
+     * until the caller releases it with `finishUpload({ jobId })` or the tab
+     * closes. Each tab writes under its own directory and holds a Web Lock named
+     * after it for its whole life; every compress removes the directories whose
+     * lock nobody holds any more, i.e. those of closed tabs. A failed or cancelled
+     * job deletes its own file straight away.
+     */
+    const OPFS_ROOT = 'native-video-compressor';
+    const lockName = (tabId) => `${OPFS_ROOT}:${tabId}`;
+    let tabId = null;
+    const getTabId = () => (tabId !== null && tabId !== void 0 ? tabId : (tabId = crypto.randomUUID()));
+    let fileCount = 0;
+    // Memoised apart from the directories: they are reopened after site data is
+    // cleared, but this tab still holds its lock, and requesting it again would
+    // wait forever on ourselves.
+    let tabLock = null;
+    let tabDirsPromise = null;
+    // A rejected request (e.g. a sandboxed iframe) rejects here, so openTabDirs
+    // fails and the caller buffers in memory instead of waiting forever.
+    const holdTabLock = () => new Promise((granted, rejected) => {
+        navigator.locks
+            .request(lockName(getTabId()), () => {
+            granted();
+            return new Promise(() => undefined);
+        })
+            .catch(rejected);
+    });
+    const sweepClosedTabs = async (base) => {
+        // Names first, locks second: a tab that creates its directory between the two
+        // reads already holds its lock, so it is never mistaken for a closed one.
+        const names = [];
+        for await (const name of base.keys())
+            names.push(name);
+        const { held = [] } = await navigator.locks.query();
+        const live = new Set(held.map((l) => l.name));
+        for (const name of names) {
+            if (!live.has(lockName(name)))
+                await base.removeEntry(name, { recursive: true }).catch(() => undefined);
+        }
+    };
+    const openTabDirs = async () => {
+        const base = await (await navigator.storage.getDirectory()).getDirectoryHandle(OPFS_ROOT, { create: true });
+        if (navigator.locks) {
+            await (tabLock !== null && tabLock !== void 0 ? tabLock : (tabLock = holdTabLock().catch((e) => {
+                tabLock = null;
+                throw e;
+            })));
+        }
+        return { base, dir: await base.getDirectoryHandle(getTabId(), { create: true }) };
+    };
+    /** Null when OPFS or `createWritable` (missing on Safari's main thread) isn't there. */
+    const createOpfsOutput = async () => {
+        var _a;
+        try {
+            if (typeof navigator === 'undefined' || !((_a = navigator.storage) === null || _a === void 0 ? void 0 : _a.getDirectory))
+                return null;
+            const { base, dir } = await (tabDirsPromise !== null && tabDirsPromise !== void 0 ? tabDirsPromise : (tabDirsPromise = openTabDirs().catch((e) => {
+                tabDirsPromise = null;
+                throw e;
+            })));
+            // Without Web Locks another tab's live files can't be told apart: no sweep.
+            if (navigator.locks)
+                await sweepClosedTabs(base).catch(() => undefined);
+            const name = `${++fileCount}.mp4`;
+            const handle = await dir.getFileHandle(name, { create: true }).catch((e) => {
+                // The directory was removed under us (site data cleared): reopen it next time.
+                if ((e === null || e === void 0 ? void 0 : e.name) === 'NotFoundError')
+                    tabDirsPromise = null;
+                throw e;
+            });
+            if (typeof handle.createWritable !== 'function') {
+                await dir.removeEntry(name).catch(() => undefined);
+                return null;
+            }
+            const writable = await handle.createWritable();
+            const discard = async () => {
+                // Rejects harmlessly once mediabunny holds the writer; it closes it then.
+                await writable.abort().catch(() => undefined);
+                await dir.removeEntry(name).catch(() => undefined);
+            };
+            // OPFS files carry no MIME type, and callers derive the extension from it.
+            const read = async () => (await handle.getFile()).slice(0, undefined, 'video/mp4');
+            return { writable, read, discard };
+        }
+        catch (e) {
+            console.warn('[compress] OPFS unavailable, buffering output in memory:', e);
+            return null;
+        }
+    };
+
+    /**
+     * Rejection shape for every coded failure. `code` matches what `call.reject`
      * puts on the error object on iOS/Android, so one `error.code === 'CANCELLED'`
-     * check works on every platform — and on both web engines below.
+     * check works on every platform and on both web engines below.
      */
-    class CancelledError extends Error {
-        constructor() {
-            super('Đã hủy nén');
-            this.code = CANCELLED;
-            this.name = 'CancelledError';
+    class CompressError extends Error {
+        constructor(code, message) {
+            super(message);
+            this.code = code;
+            this.name = 'CompressError';
         }
     }
+    const cancelledError = () => new CompressError(CANCELLED, 'Đã hủy nén');
+    const isQuotaError = (e) => {
+        const { name, cause } = (e !== null && e !== void 0 ? e : {});
+        return name === 'QuotaExceededError' || (!!cause && isQuotaError(cause));
+    };
+    /** ffmpeg.wasm copies the whole input into wasm memory (~2 GB ceiling). */
+    const MAX_FFMPEG_INPUT_BYTES = 200 * 1024 * 1024;
     /**
-     * WebCodecs target per quality tier: cap height + a bitrate ceiling. The
-     * quantizer (constant 26, CRF-like) drives quality where the encoder honours
-     * it; H.264 on most browsers is bitrate-driven, so `bitrate` is the real knob.
-     * fps is capped to 30 at call time (never upsampled). Audio is left to
-     * mediabunny, which re-encodes to AAC for the MP4 container.
+     * Per quality tier. `shortSide` caps the shorter display side, so portrait and
+     * landscape get the same box as on iOS. WebCodecs: that + a bitrate ceiling; the quantizer
+     * (constant 26, CRF-like) drives quality where the encoder honours it, but
+     * H.264 on most browsers is bitrate-driven, so `bitrate` is the real knob.
+     * ffmpeg: same short side, `crf` and `audioBitrate`. fps is capped to 30 at call
+     * time (never upsampled). On WebCodecs audio is left to mediabunny, which
+     * re-encodes to AAC for the MP4 container.
      */
-    const WEBCODECS_LADDER = {
-        VERY_HIGH: { height: 1080, bitrate: 4000000 },
-        HIGH: { height: 720, bitrate: 2000000 },
-        MEDIUM: { height: 540, bitrate: 1200000 },
-        LOW: { height: 480, bitrate: 1000000 },
-        '360P': { height: 360, bitrate: 700000 },
-        VERY_LOW: { height: 240, bitrate: 350000 },
+    const QUALITY_LADDER = {
+        VERY_HIGH: { shortSide: 1080, bitrate: 4000000, crf: 23, audioBitrate: '128k' },
+        HIGH: { shortSide: 720, bitrate: 2000000, crf: 28, audioBitrate: '128k' },
+        MEDIUM: { shortSide: 540, bitrate: 1200000, crf: 30, audioBitrate: '96k' },
+        LOW: { shortSide: 480, bitrate: 1000000, crf: 32, audioBitrate: '96k' },
+        '360P': { shortSide: 360, bitrate: 700000, crf: 28, audioBitrate: '64k' },
+        VERY_LOW: { shortSide: 240, bitrate: 350000, crf: 35, audioBitrate: '48k' },
     };
     const WEBCODECS_QUANTIZER = 26;
+    // Never upscales. Mediabunny derives the other side from the aspect ratio and rounds both up to even.
+    const webCodecsSize = (displayWidth, displayHeight, shortSide) => {
+        const side = Math.min(shortSide, displayWidth, displayHeight);
+        return displayHeight > displayWidth ? { width: side } : { height: side };
+    };
+    // iw/ih are post-autorotate here: ffmpeg inserts the transpose ahead of -vf.
+    // Never upscales; trunc keeps an odd source side even for libx264.
+    const ffmpegScaleFilter = (shortSide) => `scale=w='if(gt(iw,ih),-2,min(${shortSide},trunc(iw/2)*2))':h='if(gt(iw,ih),min(${shortSide},trunc(ih/2)*2),-2)'`;
     const FPS_CAP = 30;
+    const MIN_VIDEO_BITRATE = 200000;
+    // A lean source re-encoded at the tier bitrate comes out larger than it went in.
+    // The floor stops a broken source estimate from producing an unwatchable file.
+    const capBitrate = (target, sourceBitrate, floor, headroom = 1) => sourceBitrate && sourceBitrate > 0 ? Math.min(target, Math.max(floor, Math.round(sourceBitrate * headroom))) : target;
+    // H.264 needs about 1.5x the bitrate of these codecs for the same picture.
+    const codecHeadroom = (codec) => codec === 'hevc' || codec === 'vp9' || codec === 'av1' ? 1.5 : 1;
+    // Cap fps at 30, but never upsample. A failed probe leaves the source rate and bitrate untouched.
+    const probeVideoStats = async (track) => {
+        try {
+            const stats = await (track === null || track === void 0 ? void 0 : track.computePacketStats(100));
+            if (!stats)
+                return {};
+            return {
+                frameRate: stats.averagePacketRate > 0 ? Math.min(FPS_CAP, Math.round(stats.averagePacketRate)) : undefined,
+                bitrate: stats.averageBitrate,
+            };
+        }
+        catch (_a) {
+            return {};
+        }
+    };
     const CORE_BASE_URL = 'https://unpkg.com/@ffmpeg/core@0.12.6/dist/esm';
     /**
      * Cancelling means terminating the worker, which drops the loaded core with
@@ -73,28 +219,42 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
             this.isLoaded = false;
             /** The mediabunny conversion running now, so `cancel()` can abort it. */
             this.activeConversion = null;
-            /** The job `compressVideo` is running right now, for `cancel({ jobId })`. */
-            this.currentJobId = null;
+            /** The job `compressVideo` is running right now; a fresh object per call, so two calls never look alike. */
+            this.currentJob = null;
             this.cancelRequested = false;
+            /** Kept OPFS outputs by jobId, deleted by `finishUpload`. */
+            this.keptOutputs = new Map();
         }
         async initialize() {
-            // WebCodecs (the primary path) needs no core download, so there is nothing
-            // to warm. Eagerly loading the ffmpeg core here would pull ~30 MB for a
-            // path most compresses never take. The fallback lazy-loads its core on
-            // first use. Kept as a resolving no-op so callers that await it still pass.
+            // No-op: preloading the ~30 MB ffmpeg core would cost most compresses a download they never use.
             return { success: true, message: 'ready' };
         }
+        async finishUpload({ jobId }) {
+            const output = this.keptOutputs.get(jobId);
+            if (!output)
+                return { released: false };
+            this.keptOutputs.delete(jobId);
+            await output.discard();
+            return { released: true };
+        }
         async compressVideo(options) {
             var _a, _b;
-            this.currentJobId = (_a = options.jobId) !== null && _a !== void 0 ? _a : 'default';
+            const job = { id: (_a = options.jobId) !== null && _a !== void 0 ? _a : 'default' };
+            if (this.currentJob)
+                this.stopEngines();
+            this.currentJob = job;
             this.cancelRequested = false;
+            // A job the caller gave up on (e.g. a stall timeout) runs on until its next
+            // await returns. Once another job has started, the shared flags above speak
+            // for that job, not this one, so a superseded job counts as cancelled.
+            const isSuperseded = () => this.currentJob !== job;
             // Checked at every stage boundary, not just around the encode: cancelling
             // an engine only reaches work already handed to it, so a cancel during the
             // source fetch or before init has nothing to interrupt and would otherwise
             // let the compress carry on as if nothing had happened.
             const throwIfCancelled = () => {
-                if (this.cancelRequested)
-                    throw new CancelledError();
+                if (this.cancelRequested || isSuperseded())
+                    throw cancelledError();
             };
             try {
                 throwIfCancelled();
@@ -103,18 +263,22 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
                 const quality = (_b = options.quality) !== null && _b !== void 0 ? _b : 'MEDIUM';
                 if (await this.canUseWebCodecs(quality)) {
                     try {
-                        const result = await this.compressWithWebCodecs(blob, quality, throwIfCancelled);
+                        const result = await this.compressWithWebCodecs(blob, quality, job.id, throwIfCancelled);
                         if (result)
                             return result;
-                        // null → conversion invalid / tracks discarded → fall back to ffmpeg.
                     }
                     catch (e) {
                         if ((e === null || e === void 0 ? void 0 : e.code) === CANCELLED)
                             throw e; // user cancel: never fall back
+                        // Not to ffmpeg either: it needs even more room, and its size cap would misreport this as TOO_LARGE_FOR_WEB.
+                        if (isQuotaError(e))
+                            throw new CompressError(STORAGE_FULL, 'Không đủ dung lượng lưu trữ để nén video');
                         console.warn('[compress] WebCodecs failed, falling back to ffmpeg:', e);
-                        throwIfCancelled();
                     }
                 }
+                throwIfCancelled();
+                if (blob.size > MAX_FFMPEG_INPUT_BYTES)
+                    throw new CompressError(TOO_LARGE_FOR_WEB, 'Video quá lớn để nén trên trình duyệt này');
                 return await this.compressWithFfmpeg(blob, quality, throwIfCancelled);
             }
             catch (error) {
@@ -127,9 +291,11 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
                 throw error;
             }
             finally {
-                this.currentJobId = null;
-                this.cancelRequested = false;
-                this.activeConversion = null;
+                if (!isSuperseded()) {
+                    this.currentJob = null;
+                    this.cancelRequested = false;
+                    this.activeConversion = null;
+                }
             }
         }
         /**
@@ -137,30 +303,33 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
          * so acting on both is safe.
          *
          * WebCodecs: `conversion.cancel()` makes the in-flight `execute()` reject
-         * with `ConversionCanceledError`, surfaced as a `CancelledError` below.
+         * with `ConversionCanceledError`, surfaced as a CANCELLED `CompressError` below.
          * ffmpeg: `exec()` runs synchronously inside the worker and never reaches a
          * message poll while encoding, so `worker.terminate()` is the only way to
          * stop it — its cost is the loaded core, which is why the core URLs are
          * cached above.
          */
         async cancel(options) {
-            var _a;
-            if (!this.currentJobId)
+            if (!this.currentJob)
                 return { cancelled: false };
-            if ((options === null || options === void 0 ? void 0 : options.jobId) && options.jobId !== this.currentJobId)
+            if ((options === null || options === void 0 ? void 0 : options.jobId) && options.jobId !== this.currentJob.id)
                 return { cancelled: false };
             // Set even when neither engine exists yet: the job may still be fetching
             // the source or inside loadFFmpeg, which read this flag at their boundaries.
             this.cancelRequested = true;
+            this.stopEngines();
+            return { cancelled: true };
+        }
+        stopEngines() {
+            var _a;
             const conversion = this.activeConversion;
             this.activeConversion = null;
-            // Fire-and-forget: the CancelledError surfaces from the execute() rejection,
+            // Fire-and-forget: the CANCELLED error surfaces from the execute() rejection,
             // not from here; awaiting would only make cancel() slower.
             conversion === null || conversion === void 0 ? void 0 : conversion.cancel().catch(() => undefined);
             (_a = this.ffmpeg) === null || _a === void 0 ? void 0 : _a.terminate();
             this.ffmpeg = null;
             this.isLoaded = false;
-            return { cancelled: true };
         }
         async fetchSourceBlob(sourcePath) {
             try {
@@ -174,8 +343,9 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
         }
         async canUseWebCodecs(quality) {
             try {
-                const { bitrate } = WEBCODECS_LADDER[quality];
+                const { bitrate } = QUALITY_LADDER[quality];
                 return await mediabunny.canEncodeVideo('avc', {
+                    hardwareAcceleration: 'no-preference',
                     quality: new mediabunny.Quality({ quantizer: WEBCODECS_QUANTIZER, bitrate }),
                 });
             }
@@ -183,71 +353,104 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
                 return false;
             }
         }
-        async compressWithWebCodecs(blob, quality, throwIfCancelled) {
-            const { height, bitrate } = WEBCODECS_LADDER[quality];
-            const input = new mediabunny.Input({ formats: mediabunny.ALL_FORMATS, source: new mediabunny.BlobSource(blob) });
-            const output = new mediabunny.Output({ format: new mediabunny.Mp4OutputFormat(), target: new mediabunny.BufferTarget() });
-            // Cap fps at 30, but never upsample: probe the source and take the min.
-            // A failed probe just omits frameRate, leaving the source rate untouched.
-            let frameRate;
+        async compressWithWebCodecs(blob, quality, jobId, throwIfCancelled) {
+            const opfs = await createOpfsOutput();
+            console.debug(`[compress] engine=webcodecs target=${opfs ? 'opfs' : 'buffer'}`);
+            let output;
+            let kept = false;
             try {
-                const track = await input.getPrimaryVideoTrack();
-                if (track) {
-                    const stats = await track.computePacketStats(100);
-                    if (stats.averagePacketRate > 0) {
-                        frameRate = Math.min(FPS_CAP, Math.round(stats.averagePacketRate));
-                    }
+                const input = new mediabunny.Input({ formats: mediabunny.ALL_FORMATS, source: new mediabunny.BlobSource(blob) });
+                output = new mediabunny.Output({
+                    format: new mediabunny.Mp4OutputFormat(),
+                    target: opfs ? new mediabunny.StreamTarget(opfs.writable, { chunked: true }) : new mediabunny.BufferTarget(),
+                });
+                if (!(await this.runConversion(input, output, QUALITY_LADDER[quality], throwIfCancelled)))
+                    return null;
+                let outBlob;
+                if (opfs) {
+                    outBlob = await opfs.read();
                 }
+                else {
+                    const buffer = output.target.buffer;
+                    if (!buffer)
+                        throw new Error('WebCodecs produced no output');
+                    outBlob = new Blob([buffer], { type: 'video/mp4' });
+                }
+                kept = true;
+                if (opfs)
+                    this.keptOutputs.set(jobId, opfs);
+                return { success: true, destPath: URL.createObjectURL(outBlob) };
             }
-            catch (_a) {
-                frameRate = undefined;
+            finally {
+                if (!kept) {
+                    // Closes the writable first, which otherwise keeps the entry locked against removal.
+                    await (output === null || output === void 0 ? void 0 : output.cancel().catch(() => undefined));
+                    await (opfs === null || opfs === void 0 ? void 0 : opfs.discard());
+                }
             }
+        }
+        /** False when mediabunny can't convert this input. */
+        async runConversion(input, output, { shortSide, bitrate }, throwIfCancelled) {
+            const track = await input.getPrimaryVideoTrack();
+            const { frameRate, bitrate: sourceBitrate } = await probeVideoStats(track);
+            const size = track ? webCodecsSize(await track.getDisplayWidth(), await track.getDisplayHeight(), shortSide) : {};
             throwIfCancelled();
             const conversion = await mediabunny.Conversion.init({
                 input,
                 output,
-                video: Object.assign({ height, quality: new mediabunny.Quality({ quantizer: WEBCODECS_QUANTIZER, bitrate }), hardwareAcceleration: 'prefer-hardware' }, (frameRate ? { frameRate } : {})),
+                video: {
+                    ...size,
+                    quality: new mediabunny.Quality({
+                        quantizer: WEBCODECS_QUANTIZER,
+                        bitrate: capBitrate(bitrate, sourceBitrate, MIN_VIDEO_BITRATE, codecHeadroom(track === null || track === void 0 ? void 0 : track.codec)),
+                    }),
+                    // Not 'prefer-hardware': machines without a hardware H.264 encoder
+                    // (Linux, VMs, headless) then fail mid-encode and drop to ffmpeg.wasm.
+                    // The browser still picks the hardware encoder when it has one, and the
+                    // canEncodeVideo probe asks the same question, so probe and encode agree.
+                    hardwareAcceleration: 'no-preference',
+                    ...(frameRate ? { frameRate } : {}),
+                },
+                // The default copies the input's raw udta metadata tags, GPS location included.
+                tags: {},
             });
             if (!conversion.isValid) {
                 console.warn('[compress] WebCodecs conversion invalid:', conversion.discardedTracks.map((t) => t.reason));
-                return null;
+                return false;
             }
+            throwIfCancelled();
             this.activeConversion = conversion;
             this.notifyListeners('onProgress', { status: 'started', percent: 0 });
             conversion.onProgress = (progress) => {
-                this.notifyListeners('onProgress', { status: 'progress', percent: Math.round(progress * 100) });
+                if (this.activeConversion === conversion)
+                    this.notifyListeners('onProgress', { status: 'progress', percent: Math.round(progress * 100) });
             };
-            throwIfCancelled();
             try {
                 await conversion.execute();
             }
             catch (e) {
                 if (this.cancelRequested || e instanceof mediabunny.ConversionCanceledError)
-                    throw new CancelledError();
+                    throw cancelledError();
                 throw e;
             }
-            const buffer = output.target.buffer;
-            if (!buffer)
-                throw new Error('WebCodecs produced no output');
-            const outBlob = new Blob([buffer], { type: 'video/mp4' });
-            return { success: true, destPath: URL.createObjectURL(outBlob) };
+            throwIfCancelled();
+            return true;
         }
-        async loadFFmpeg() {
+        async loadFFmpeg(throwIfCancelled) {
             if (this.isLoaded && this.ffmpeg)
                 return;
+            throwIfCancelled();
             this.notifyListeners('onProgress', { status: 'loading_core', percent: 0 });
-            // Built on a local, published to the field only once it is ready and still
-            // wanted. Assigning `this.ffmpeg` up front and setting `isLoaded` after the
-            // await left a window where a cancel could null the instance and the load,
-            // finishing a moment later, would set `isLoaded = true` on nothing at all —
-            // after which every compressVideo threw 'FFmpeg failed to load' for the
-            // rest of the page's life.
+            // Published only once loaded and still wanted, so a cancel mid-load can't leave `isLoaded` set on a dropped instance.
             const instance = new ffmpeg.FFmpeg();
             instance.on('progress', ({ progress }) => {
-                this.notifyListeners('onProgress', { status: 'progress', percent: Math.round(progress * 100) });
+                // Once published the instance serves every later job; before that, or
+                // after cancel() dropped it, its events belong to no job.
+                if (this.ffmpeg === instance)
+                    this.notifyListeners('onProgress', { status: 'progress', percent: Math.round(progress * 100) });
             });
             instance.on('log', ({ message }) => {
-                console.log('[FFmpeg Log]', message);
+                console.debug('[FFmpeg Log]', message);
             });
             try {
                 await instance.load(await loadCoreURLs());
@@ -259,16 +462,19 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
             }
             // Cancelled while this was loading. Terminate what we just built rather
             // than publish it — the caller asked for none of it.
-            if (this.cancelRequested) {
+            try {
+                throwIfCancelled();
+            }
+            catch (e) {
                 instance.terminate();
-                throw new CancelledError();
+                throw e;
             }
             this.ffmpeg = instance;
             this.isLoaded = true;
         }
         async compressWithFfmpeg(blob, quality, throwIfCancelled) {
             if (!this.isLoaded) {
-                await this.loadFFmpeg();
+                await this.loadFFmpeg(throwIfCancelled);
             }
             throwIfCancelled();
             if (!this.ffmpeg) {
@@ -276,72 +482,39 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
             }
             // Bound once. `this.ffmpeg` is nulled by cancel(), so reading it after any
             // of the awaits below can hand back null on a reference the compiler
-            // narrowed here — surfacing a cancel as a TypeError, not a CancelledError.
+            // narrowed here — surfacing a cancel as a TypeError, not a CANCELLED error.
             const ffmpeg = this.ffmpeg;
+            console.debug('[compress] engine=ffmpeg');
             this.notifyListeners('onProgress', { status: 'started', percent: 0 });
             const inputFileName = 'input.mp4';
             const outputFileName = 'output.mp4';
-            let crf = '28';
-            let scale = '';
-            let audioBitrate = '128k';
-            switch (quality) {
-                case 'VERY_HIGH':
-                    crf = '23';
-                    scale = '-vf scale=-2:1080';
-                    audioBitrate = '128k';
-                    break;
-                case 'HIGH':
-                    crf = '28';
-                    scale = '-vf scale=-2:720';
-                    audioBitrate = '128k';
-                    break;
-                case 'MEDIUM':
-                    crf = '30';
-                    scale = '-vf scale=-2:540';
-                    audioBitrate = '96k';
-                    break;
-                case 'LOW':
-                    crf = '32';
-                    scale = '-vf scale=-2:480';
-                    audioBitrate = '96k';
-                    break;
-                case '360P':
-                    crf = '28';
-                    scale = '-vf scale=-2:360';
-                    audioBitrate = '64k';
-                    break;
-                case 'VERY_LOW':
-                    crf = '35';
-                    scale = '-vf scale=-2:240';
-                    audioBitrate = '48k';
-                    break;
-            }
+            const { shortSide, crf, audioBitrate } = QUALITY_LADDER[quality];
             const inputData = new Uint8Array(await blob.arrayBuffer());
             try {
                 await ffmpeg.writeFile(inputFileName, inputData);
             }
             catch (err) {
-                if (this.cancelRequested)
-                    throw new CancelledError();
+                throwIfCancelled();
                 console.error('[FFmpeg] Error writing to FS:', err);
                 throw new Error('Could not write to FFmpeg FS');
             }
             throwIfCancelled();
-            const args = ['-i', inputFileName];
-            args.push('-c:v', 'libx264', '-preset', 'superfast', '-crf', crf);
-            if (scale) {
-                args.push(...scale.split(' '));
-            }
-            args.push('-c:a', 'aac', '-b:a', audioBitrate);
-            args.push(outputFileName);
+            // ffmpeg copies global metadata by default, including the GPS location (©xyz / loci).
+            // prettier-ignore
+            const args = [
+                '-i', inputFileName, '-map_metadata', '-1',
+                '-c:v', 'libx264', '-preset', 'superfast', '-crf', String(crf),
+                '-vf', ffmpegScaleFilter(shortSide),
+                '-c:a', 'aac', '-b:a', audioBitrate,
+                outputFileName,
+            ];
             try {
                 await ffmpeg.exec(args);
             }
             catch (err) {
                 // terminate() rejects every in-flight call, so a cancel arrives here
                 // looking like a generic failure unless we name it.
-                if (this.cancelRequested)
-                    throw new CancelledError();
+                throwIfCancelled();
                 console.error('[FFmpeg] Error executing command:', err);
                 throw new Error('FFmpeg execution failed');
             }
@@ -351,8 +524,7 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
                 data = await ffmpeg.readFile(outputFileName);
             }
             catch (err) {
-                if (this.cancelRequested)
-                    throw new CancelledError();
+                throwIfCancelled();
                 console.error('[FFmpeg] Error reading output file:', err);
                 throw new Error('Could not read FFmpeg output');
             }
@@ -365,13 +537,19 @@ var capacitorNativeVideoCompressor = (function (exports, core, ffmpeg, util, med
 
     var web = /*#__PURE__*/Object.freeze({
         __proto__: null,
-        NativeVideoCompressorWeb: NativeVideoCompressorWeb
+        NativeVideoCompressorWeb: NativeVideoCompressorWeb,
+        capBitrate: capBitrate,
+        codecHeadroom: codecHeadroom,
+        ffmpegScaleFilter: ffmpegScaleFilter,
+        webCodecsSize: webCodecsSize
     });
 
     exports.CANCELLED = CANCELLED;
     exports.NativeVideoCompressor = NativeVideoCompressor;
+    exports.STORAGE_FULL = STORAGE_FULL;
+    exports.TOO_LARGE_FOR_WEB = TOO_LARGE_FOR_WEB;
 
     return exports;
 
-})({}, capacitorExports, ffmpeg, util, mediabunny);
+})({}, capacitorExports, FFmpegWASM, FFmpegUtil, Mediabunny);
 //# sourceMappingURL=plugin.js.map