@remotion/webcodecs 4.0.251 → 4.0.252

package/dist/auto-select-writer.d.ts

@@ -1,3 +1,3 @@
+import type { WriterInterface } from '@remotion/media-parser';
 import type { LogLevel } from './log';
-import type { WriterInterface } from './writers/writer';
 export declare const autoSelectWriter: (writer: WriterInterface | undefined, logLevel: LogLevel) => Promise<WriterInterface>;

package/dist/can-copy-video-track.js

@@ -24,7 +24,8 @@ const canCopyVideoTrack = ({ outputContainer, rotationToApply, inputContainer, r
             inputTrack.codecWithoutConfig === 'vp9');
     }
     if (outputContainer === 'mp4') {
-        return (inputTrack.codecWithoutConfig === 'h264' &&
+        return ((inputTrack.codecWithoutConfig === 'h264' ||
+            inputTrack.codecWithoutConfig === 'h265') &&
             (inputContainer === 'mp4' || inputContainer === 'avi'));
     }
     if (outputContainer === 'wav') {

package/dist/choose-correct-hevc-profile.d.ts

@@ -0,0 +1,5 @@
+export declare const chooseCorrectHevcProfile: ({ width, height, fps, }: {
+    width: number;
+    height: number;
+    fps: number | null;
+}) => string;

package/dist/choose-correct-hevc-profile.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.chooseCorrectHevcProfile = void 0;
+const hevc_levels_1 = require("./hevc-levels");
+const chooseCorrectHevcProfile = ({ width, height, fps, }) => {
+    const profile = hevc_levels_1.hevcLevels.find((p) => {
+        return p.maxResolutionsAndFrameRates.some((max) => {
+            if (width > max.width) {
+                return false;
+            }
+            if (height > max.height) {
+                return false;
+            }
+            // if has no fps, use 60 as a conservative fallback
+            const fallbackFps = fps !== null && fps !== void 0 ? fps : 60;
+            return fallbackFps <= max.fps;
+        });
+    });
+    if (!profile) {
+        throw new Error(`No suitable HEVC profile found for ${width}x${height}@${fps}fps`);
+    }
+    // HEVC codec string format: hev1.2.${level_hex} or hvc1.2.${level_hex}
+    // We'll use hvc1 as it's more widely supported
+    return `hvc1.${
+    // Profile
+    // 1 = Main
+    // 2 = Main 10
+    // Chrome seems to support only Main
+    1}.${
+    // Profile space
+    // Unclear which value to set, but 0 works
+    0}.${
+    // L = Main tier
+    // H = High tier
+    // TODO: Select high tier if resolution is big
+    'L'}${
+    // Level
+    Math.round(Number(profile.level) * 30)}.${
+    // Bit depth
+    'b0'}`;
+};
+exports.chooseCorrectHevcProfile = chooseCorrectHevcProfile;

package/dist/convert-media.d.ts

@@ -2,15 +2,14 @@
  * Copyright (c) 2025 Remotion AG
  * For licensing, see: https://remotion.dev/docs/webcodecs#license
  */
-import type { AudioTrack, LogLevel, Options, ParseMediaFields, ParseMediaOptions, VideoTrack } from '@remotion/media-parser';
+import type { AudioTrack, LogLevel, Options, ParseMediaFields, ParseMediaOptions, VideoTrack, WriterInterface } from '@remotion/media-parser';
 import type { ParseMediaCallbacks } from '@remotion/media-parser';
 import type { ConvertMediaAudioCodec } from './get-available-audio-codecs';
-import type { ConvertMediaContainer } from './get-available-containers';
-import type { ConvertMediaVideoCodec } from './get-available-video-codecs';
+import { type ConvertMediaContainer } from './get-available-containers';
+import { type ConvertMediaVideoCodec } from './get-available-video-codecs';
 import { type ConvertMediaOnAudioTrackHandler } from './on-audio-track-handler';
 import { type ConvertMediaOnVideoTrackHandler } from './on-video-track-handler';
 import type { ResizeOperation } from './resizing/mode';
-import type { WriterInterface } from './writers/writer';
 export type ConvertMediaProgress = {
     decodedVideoFrames: number;
     decodedAudioFrames: number;

package/dist/convert-media.js

@@ -15,6 +15,8 @@ const progress_tracker_1 = require("./create/progress-tracker");
 const with_resolvers_1 = require("./create/with-resolvers");
 const error_cause_1 = __importDefault(require("./error-cause"));
 const generate_output_filename_1 = require("./generate-output-filename");
+const get_available_containers_1 = require("./get-available-containers");
+const get_available_video_codecs_1 = require("./get-available-video-codecs");
 const log_1 = require("./log");
 const on_audio_track_1 = require("./on-audio-track");
 const on_video_track_1 = require("./on-video-track");
@@ -26,11 +28,11 @@ const convertMedia = async function ({ src, onVideoFrame, onAudioData, onProgres
     if (userPassedAbortSignal === null || userPassedAbortSignal === void 0 ? void 0 : userPassedAbortSignal.aborted) {
         return Promise.reject(new error_cause_1.default('Aborted'));
     }
-    if (container !== 'webm' && container !== 'mp4' && container !== 'wav') {
-        return Promise.reject(new TypeError('Only `to: "webm"`, `to: "mp4"` and `to: "wav"` is supported currently'));
+    if (container !== 'webm' && get_available_containers_1.availableContainers.indexOf(container) === -1) {
+        return Promise.reject(new TypeError(`Only the following values for "container" are supported currently: ${JSON.stringify(get_available_containers_1.availableContainers)}`));
     }
-    if (videoCodec && videoCodec !== 'vp8' && videoCodec !== 'vp9') {
-        return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
+    if (videoCodec && get_available_video_codecs_1.availableVideoCodecs.indexOf(videoCodec) === -1) {
+        return Promise.reject(new TypeError(`Only the following values for "videoCodec" are supported currently: ${JSON.stringify(get_available_video_codecs_1.availableVideoCodecs)}`));
     }
     const { resolve, reject, getPromiseToImmediatelyReturn } = (0, with_resolvers_1.withResolversAndWaitForReturn)();
     const controller = new AbortController();
@@ -147,7 +149,7 @@ const convertMedia = async function ({ src, onVideoFrame, onAudioData, onProgres
     })
         .then(() => {
         resolve({
-            save: state.save,
+            save: state.getBlob,
             remove: state.remove,
             finalState: throttledState.get(),
         });

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.d.ts

@@ -10,6 +10,17 @@ export type Avc1Data = {
     depth: number;
     type: 'avc1-data';
 };
+export type Hvc1Data = {
+    pasp: Uint8Array;
+    hvccBox: Uint8Array;
+    width: number;
+    height: number;
+    horizontalResolution: number;
+    verticalResolution: number;
+    compressorName: string;
+    depth: number;
+    type: 'hvc1-data';
+};
 export type Mp4aData = {
     type: 'mp4a-data';
     sampleRate: number;

package/dist/create/iso-base-media/codec-specific/create-codec-specific-data.js

@@ -2,22 +2,40 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createCodecSpecificData = void 0;
 const create_avcc_1 = require("../trak/mdia/minf/stbl/stsd/create-avcc");
+const create_hvcc_1 = require("../trak/mdia/minf/stbl/stsd/create-hvcc");
 const create_pasp_1 = require("../trak/mdia/minf/stbl/stsd/create-pasp");
 const avc1_1 = require("./avc1");
+const hvc1_1 = require("./hvc1");
 const mp4a_1 = require("./mp4a");
 const createCodecSpecificData = (track) => {
     if (track.type === 'video') {
-        return (0, avc1_1.createAvc1Data)({
-            avccBox: (0, create_avcc_1.createAvccBox)(track.codecPrivate),
-            compressorName: 'WebCodecs',
-            depth: 24,
-            horizontalResolution: 72,
-            verticalResolution: 72,
-            height: track.height,
-            width: track.width,
-            pasp: (0, create_pasp_1.createPasp)(1, 1),
-            type: 'avc1-data',
-        });
+        if (track.codec === 'h264') {
+            return (0, avc1_1.createAvc1Data)({
+                avccBox: (0, create_avcc_1.createAvccBox)(track.codecPrivate),
+                compressorName: 'WebCodecs',
+                depth: 24,
+                horizontalResolution: 72,
+                verticalResolution: 72,
+                height: track.height,
+                width: track.width,
+                pasp: (0, create_pasp_1.createPasp)(1, 1),
+                type: 'avc1-data',
+            });
+        }
+        if (track.codec === 'h265') {
+            return (0, hvc1_1.createHvc1Data)({
+                hvccBox: (0, create_hvcc_1.createHvccBox)(track.codecPrivate),
+                compressorName: 'WebCodecs',
+                depth: 24,
+                horizontalResolution: 72,
+                verticalResolution: 72,
+                height: track.height,
+                width: track.width,
+                pasp: (0, create_pasp_1.createPasp)(1, 1),
+                type: 'hvc1-data',
+            });
+        }
+        throw new Error('Unsupported codec specific data ' + track.codec);
     }
     if (track.type === 'audio') {
         return (0, mp4a_1.createMp4a)({

package/dist/create/iso-base-media/codec-specific/hvc1.d.ts

@@ -0,0 +1,2 @@
+import type { Hvc1Data } from './create-codec-specific-data';
+export declare const createHvc1Data: ({ compressorName, depth, height, horizontalResolution, hvccBox, pasp, verticalResolution, width, }: Hvc1Data) => Uint8Array;

package/dist/create/iso-base-media/codec-specific/hvc1.js

@@ -0,0 +1,48 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHvc1Data = void 0;
+const matroska_utils_1 = require("../../matroska/matroska-utils");
+const primitives_1 = require("../primitives");
+const createHvc1Data = ({ compressorName, depth, height, horizontalResolution, hvccBox, pasp, verticalResolution, width, }) => {
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('hvc1'),
+        // reserved
+        new Uint8Array([0, 0, 0, 0, 0, 0]),
+        // data_reference_index
+        new Uint8Array([0, 1]),
+        // version
+        new Uint8Array([0, 0]),
+        // revisionLevel
+        new Uint8Array([0, 0]),
+        // vendor
+        new Uint8Array([0, 0, 0, 0]),
+        // temporalQuality
+        new Uint8Array([0, 0, 0, 0]),
+        // spatialQuality
+        new Uint8Array([0, 0, 0, 0]),
+        // width
+        (0, primitives_1.numberTo16BitUIntOrInt)(width),
+        // height
+        (0, primitives_1.numberTo16BitUIntOrInt)(height),
+        // horizontalResolution
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(horizontalResolution),
+        // verticalResolution
+        (0, primitives_1.setFixedPointSignedOrUnsigned1616Number)(verticalResolution),
+        // dataSize
+        new Uint8Array([0, 0, 0, 0]),
+        // frame count per sample
+        (0, primitives_1.numberTo16BitUIntOrInt)(1),
+        // compressor name
+        (0, primitives_1.stringToPascalString)(compressorName),
+        // depth
+        (0, primitives_1.numberTo16BitUIntOrInt)(depth),
+        // colorTableId
+        (0, primitives_1.numberTo16BitUIntOrInt)(-1),
+        // hvcc box
+        hvccBox,
+        // pasp
+        pasp,
+    ]));
+};
+exports.createHvc1Data = createHvc1Data;

package/dist/create/iso-base-media/create-iso-base-media.js

@@ -13,7 +13,11 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
         majorBrand: 'isom',
         minorBrand: 512,
     });
-    const w = await writer.createContent({ filename, mimeType: 'video/mp4' });
+    const w = await writer.createContent({
+        filename,
+        mimeType: 'video/mp4',
+        logLevel,
+    });
     await w.write(header);
     let globalDurationInUnits = 0;
     const lowestTrackTimestamps = {};
@@ -135,8 +139,8 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
     };
     const waitForFinishPromises = [];
     return {
-        save: () => {
-            return w.save();
+        getBlob: () => {
+            return w.getBlob();
         },
         remove: async () => {
             await w.remove();
@@ -177,7 +181,7 @@ const createIsoBaseMedia = async ({ writer, onBytesProgress, onMillisecondsProgr
             await updateMoov();
             await updateMdatSize();
             media_parser_1.MediaParserInternals.Log.verbose(logLevel, 'All write operations done. Waiting for finish...');
-            await w.waitForFinish();
+            await w.finish();
         },
     };
 };

package/dist/create/iso-base-media/serialize-track.js

@@ -13,7 +13,9 @@ const create_stbl_1 = require("./trak/mdia/minf/create-stbl");
 const create_vmhd_1 = require("./trak/mdia/minf/create-vmhd");
 const create_hdlr_1 = require("./udta/meta/create-hdlr");
 const serializeTrack = ({ track, durationInUnits, samplePositions, timescale, }) => {
-    if (track.codec !== 'h264' && track.codec !== 'aac') {
+    if (track.codec !== 'h264' &&
+        track.codec !== 'h265' &&
+        track.codec !== 'aac') {
         throw new Error('Currently only H.264 and AAC is supported');
     }
     return (0, create_trak_1.createTrak)({

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-hvcc.d.ts

@@ -0,0 +1 @@
+export declare const createHvccBox: (privateData: Uint8Array | null) => Uint8Array;

package/dist/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-hvcc.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createHvccBox = void 0;
+const matroska_utils_1 = require("../../../../../../matroska/matroska-utils");
+const primitives_1 = require("../../../../../primitives");
+const createHvccBox = (privateData) => {
+    if (!privateData) {
+        throw new Error('privateData is required');
+    }
+    return (0, primitives_1.addSize)((0, matroska_utils_1.combineUint8Arrays)([
+        // type
+        (0, primitives_1.stringsToUint8Array)('hvcC'),
+        privateData,
+    ]));
+};
+exports.createHvccBox = createHvccBox;

package/dist/create/matroska/cluster.d.ts

@@ -1,6 +1,6 @@
+import type { Writer } from '@remotion/media-parser';
 import { type AudioOrVideoSample } from '@remotion/media-parser';
 import type { LogLevel } from '../../log';
-import type { Writer } from '../../writers/writer';
 export declare const timestampToClusterTimestamp: (timestamp: number, timescale: number) => number;
 export declare const canFitInCluster: ({ clusterStartTimestamp, chunk, timescale, }: {
     clusterStartTimestamp: number;

package/dist/create/matroska/create-matroska-media.js

@@ -16,7 +16,11 @@ const timescale = 1000000;
 const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProgress, filename, logLevel, progressTracker, }) => {
     var _a, _b, _c, _d, _e, _f, _g;
     const header = (0, matroska_header_1.makeMatroskaHeader)();
-    const w = await writer.createContent({ filename, mimeType: 'video/webm' });
+    const w = await writer.createContent({
+        filename,
+        mimeType: 'video/webm',
+        logLevel,
+    });
     await w.write(header.bytes);
     const matroskaInfo = (0, matroska_info_1.makeMatroskaInfo)({
         timescale,
@@ -149,8 +153,8 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
                 }
             });
         },
-        save: () => {
-            return w.save();
+        getBlob: async () => {
+            return w.getBlob();
         },
         remove: async () => {
             await w.remove();
@@ -177,12 +181,12 @@ const createMatroskaMedia = async ({ writer, onBytesProgress, onMillisecondsProg
             });
             await updateSeekWrite();
             await w.write((0, matroska_cues_1.createMatroskaCues)(cues).bytes);
-            await w.waitForFinish();
             const segmentSize = w.getWrittenByteCount() -
                 segmentOffset -
                 (0, matroska_utils_1.matroskaToHex)(matroskaElements.Segment).byteLength -
                 matroska_segment_1.MATROSKA_SEGMENT_MIN_VINT_WIDTH;
             await updateSegmentSize(segmentSize);
+            await w.finish();
         },
     };
 };

package/dist/create/matroska/matroska-trackentry.js

@@ -67,6 +67,9 @@ const makeAudioCodecId = (codecId) => {
     if (codecId === 'aac') {
         return 'A_AAC';
     }
+    if (codecId === 'ac3') {
+        return 'A_AC3';
+    }
     if (codecId === 'mp3') {
         return 'A_MPEG/L3';
     }

package/dist/create/matroska/matroska-utils.d.ts

@@ -19,7 +19,7 @@ export type EbmlParsedOrUint8Array<T extends Ebml> = {
     value: EbmlValueOrUint8Array<T>;
     minVintWidth: number | null;
 };
-export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 4 | 3 | 5 | 6;
+export declare const measureEBMLVarInt: (value: number) => 2 | 1 | 6 | 5 | 3 | 4;
 export declare const getVariableInt: (value: number, minWidth: number | null) => Uint8Array;
 export declare const makeMatroskaBytes: (fields: PossibleEbmlOrUint8Array) => BytesAndOffset;
 export type PossibleEbmlOrUint8Array = Prettify<{

package/dist/create/media-fn.d.ts

@@ -1,10 +1,9 @@
-import type { AudioOrVideoSample } from '@remotion/media-parser';
+import type { AudioOrVideoSample, WriterInterface } from '@remotion/media-parser';
 import type { LogLevel } from '../log';
-import type { WriterInterface } from '../writers/writer';
 import type { MakeTrackAudio, MakeTrackVideo } from './make-track-info';
 import type { ProgressTracker } from './progress-tracker';
 export type MediaFn = {
-    save: () => Promise<Blob>;
+    getBlob: () => Promise<Blob>;
     remove: () => Promise<void>;
     addSample: (options: {
         chunk: AudioOrVideoSample;

package/dist/create/wav/create-wav.js

@@ -16,7 +16,11 @@ const numberTo16BitLittleEndian = (num) => {
 const BIT_DEPTH = 16;
 const BYTES_PER_SAMPLE = BIT_DEPTH / 8;
 const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsProgress, writer, progressTracker, }) => {
-    const w = await writer.createContent({ filename, mimeType: 'audio/wav' });
+    const w = await writer.createContent({
+        filename,
+        mimeType: 'audio/wav',
+        logLevel,
+    });
     await w.write(new Uint8Array([0x52, 0x49, 0x46, 0x46])); // "RIFF"
     const sizePosition = w.getWrittenByteCount();
     await w.write(new Uint8Array([0x00, 0x00, 0x00, 0x00])); // Remaining size
@@ -64,8 +68,8 @@ const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsPr
     };
     const waitForFinishPromises = [];
     return {
-        save: () => {
-            return w.save();
+        getBlob: () => {
+            return w.getBlob();
         },
         remove: () => {
             return w.remove();
@@ -89,7 +93,7 @@ const createWav = async ({ filename, logLevel, onBytesProgress, onMillisecondsPr
             await Promise.all(waitForFinishPromises.map((p) => p()));
             await operationProm.current;
             await updateSize();
-            await w.waitForFinish();
+            await w.finish();
         },
         addTrack: async (track) => {
             if (track.type !== 'audio') {

package/dist/esm/buffer.mjs

@@ -1,21 +1,3 @@
-var __create = Object.create;
-var __getProtoOf = Object.getPrototypeOf;
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
-var __toESM = (mod, isNodeMode, target) => {
-  target = mod != null ? __create(__getProtoOf(mod)) : {};
-  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
-  for (let key of __getOwnPropNames(mod))
-    if (!__hasOwnProp.call(to, key))
-      __defProp(to, key, {
-        get: () => mod[key],
-        enumerable: true
-      });
-  return to;
-};
-var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
-
 // src/writers/buffer-implementation/writer.ts
 var createContent = ({ filename, mimeType }) => {
   const buf = new ArrayBuffer(0, {
@@ -42,10 +24,14 @@ var createContent = ({ filename, mimeType }) => {
       writPromise = writPromise.then(() => write(arr));
       return writPromise;
     },
-    save: () => {
+    finish: async () => {
+      await writPromise;
       if (removed) {
         return Promise.reject(new Error("Already called .remove() on the result"));
       }
+      return Promise.resolve();
+    },
+    getBlob() {
       const arr = new Uint8Array(buf);
       return Promise.resolve(new File([arr.slice()], filename, { type: mimeType }));
     },
@@ -57,9 +43,6 @@ var createContent = ({ filename, mimeType }) => {
     updateDataAt: (position, newData) => {
       writPromise = writPromise.then(() => updateDataAt(position, newData));
       return writPromise;
-    },
-    waitForFinish: async () => {
-      await writPromise;
     }
   };
   return Promise.resolve(writer);