@remotion/webcodecs 4.0.211 → 4.0.213

package/dist/create-decoder.d.ts

@@ -0,0 +1,6 @@
+export declare const createDecoder: ({ onProgress, onFrame, }: {
+    onProgress: (decoded: number) => void;
+    onFrame: (frame: VideoFrame, keyframe: boolean) => void;
+}) => {
+    decoder: VideoDecoder;
+};

package/dist/create-decoder.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecoder = void 0;
+const createDecoder = ({ onProgress, onFrame, }) => {
+    let decodedFrames = 0;
+    let nextKeyFrameTimestamp = 0;
+    const decoder = new VideoDecoder({
+        async output(inputFrame) {
+            const bitmap = await createImageBitmap(inputFrame);
+            const keyFrameEveryHowManySeconds = 2;
+            let keyFrame = false;
+            if (inputFrame.timestamp >= nextKeyFrameTimestamp) {
+                keyFrame = true;
+                nextKeyFrameTimestamp =
+                    inputFrame.timestamp + keyFrameEveryHowManySeconds * 1e6;
+            }
+            const outputFrame = new VideoFrame(bitmap, {
+                timestamp: inputFrame.timestamp,
+                duration: inputFrame.duration,
+            });
+            onFrame(outputFrame, keyFrame);
+            inputFrame.close();
+            decodedFrames++;
+            onProgress(decodedFrames);
+        },
+        error(error) {
+            console.error(error);
+        },
+    });
+    return { decoder };
+};
+exports.createDecoder = createDecoder;

package/dist/decoder.d.ts

@@ -0,0 +1,7 @@
+import type { VideoSample, VideoTrack } from '@remotion/media-parser';
+export declare const createDecoder: ({ track, onFrame, }: {
+    track: VideoTrack;
+    onFrame: (frame: VideoFrame) => Promise<void>;
+}) => Promise<{
+    processSample: (sample: VideoSample) => Promise<void>;
+} | null>;

package/dist/decoder.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDecoder = void 0;
+const wait_for_dequeue_1 = require("./wait-for-dequeue");
+const createDecoder = async ({ track, onFrame, }) => {
+    if (typeof VideoDecoder === 'undefined') {
+        return null;
+    }
+    const actualConfig = {
+        ...track,
+        hardwareAcceleration: 'prefer-hardware',
+    };
+    const { supported } = await VideoDecoder.isConfigSupported(actualConfig);
+    if (!supported) {
+        return null;
+    }
+    const videoDecoder = new VideoDecoder({
+        async output(inputFrame) {
+            await onFrame(inputFrame);
+        },
+        error(error) {
+            console.error(error);
+        },
+    });
+    videoDecoder.configure(actualConfig);
+    const processSample = async (sample) => {
+        if (videoDecoder.state === 'closed') {
+            return;
+        }
+        await (0, wait_for_dequeue_1.decoderWaitForDequeue)(videoDecoder);
+        if (sample.type === 'key') {
+            await videoDecoder.flush();
+        }
+        videoDecoder.decode(new EncodedVideoChunk(sample));
+    };
+    let queue = Promise.resolve();
+    return {
+        processSample: (sample) => {
+            queue = queue.then(() => processSample(sample));
+            return queue;
+        },
+    };
+};
+exports.createDecoder = createDecoder;

package/dist/encoder.d.ts

@@ -0,0 +1,7 @@
+export declare const createEncoder: ({ width, height, onChunk, }: {
+    width: number;
+    height: number;
+    onChunk: (chunk: EncodedVideoChunk) => Promise<void>;
+}) => Promise<{
+    encodeFrame: (frame: VideoFrame) => Promise<void>;
+} | null>;

package/dist/encoder.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createEncoder = void 0;
+const get_config_1 = require("./get-config");
+const wait_for_dequeue_1 = require("./wait-for-dequeue");
+const createEncoder = async ({ width, height, onChunk, }) => {
+    if (typeof VideoEncoder === 'undefined') {
+        return Promise.resolve(null);
+    }
+    const encoder = new VideoEncoder({
+        error(error) {
+            console.error(error);
+        },
+        async output(chunk) {
+            await onChunk(chunk);
+        },
+    });
+    const config = await (0, get_config_1.getVideoEncoderConfigWithHardwareAcceleration)({
+        codec: 'vp8',
+        height,
+        width,
+    });
+    if (!config) {
+        return null;
+    }
+    encoder.configure(config);
+    let framesProcessed = 0;
+    const encodeFrame = async (frame) => {
+        await (0, wait_for_dequeue_1.encoderWaitForDequeue)(encoder);
+        encoder.encode(frame, {
+            keyFrame: framesProcessed % 40 === 0,
+        });
+        framesProcessed++;
+    };
+    let queue = Promise.resolve();
+    return {
+        encodeFrame: (frame) => {
+            queue = queue.then(() => encodeFrame(frame));
+            return queue;
+        },
+    };
+};
+exports.createEncoder = createEncoder;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remotion/webcodecs",
-  "version": "4.0.211",
+  "version": "4.0.213",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "module": "dist/esm/index.mjs",
@@ -17,7 +17,7 @@
   "author": "Jonny Burger <jonny@remotion.dev>",
   "license": "SEE LICENSE IN LICENSE.md",
   "dependencies": {
-    "@remotion/media-parser": "4.0.211"
+    "@remotion/media-parser": "4.0.213"
   },
   "peerDependencies": {},
   "devDependencies": {