@remotion/webcodecs 4.0.251 → 4.0.252

package/dist/esm/index.mjs

@@ -125,11 +125,14 @@ var createContent = async ({ filename }) => {
       writPromise = writPromise.then(() => write(arr));
       return writPromise;
     },
-    save: async () => {
+    finish: async () => {
+      await writPromise;
       try {
         await writable.close();
       } catch {
       }
+    },
+    async getBlob() {
       const newHandle = await directoryHandle.getFileHandle(actualFilename, {
         create: true
       });
@@ -141,9 +144,6 @@ var createContent = async ({ filename }) => {
       writPromise = writPromise.then(() => updateDataAt(position, data));
       return writPromise;
     },
-    waitForFinish: async () => {
-      await writPromise;
-    },
     remove
   };
   return writer;
@@ -192,10 +192,14 @@ var createContent2 = ({ 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 }));
     },
@@ -207,9 +211,6 @@ var createContent2 = ({ filename, mimeType }) => {
     updateDataAt: (position, newData) => {
       writPromise = writPromise.then(() => updateDataAt(position, newData));
       return writPromise;
-    },
-    waitForFinish: async () => {
-      await writPromise;
     }
   };
   return Promise.resolve(writer);
@@ -912,7 +913,7 @@ var canCopyVideoTrack = ({
     return inputTrack.codecWithoutConfig === "vp8" || inputTrack.codecWithoutConfig === "vp9";
   }
   if (outputContainer === "mp4") {
-    return inputTrack.codecWithoutConfig === "h264" && (inputContainer === "mp4" || inputContainer === "avi");
+    return (inputTrack.codecWithoutConfig === "h264" || inputTrack.codecWithoutConfig === "h265") && (inputContainer === "mp4" || inputContainer === "avi");
   }
   if (outputContainer === "wav") {
     return false;
@@ -1049,6 +1050,284 @@ var chooseCorrectAvc1Profile = ({
   return `avc1.6400${profile.hex}`;
 };
 
+// src/hevc-levels.ts
+var hevcLevels = [
+  {
+    level: "3.1",
+    maxBitrateMainTier: 1e4,
+    maxBitrateHighTier: null,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 720,
+        height: 480,
+        fps: 84.3
+      },
+      {
+        width: 720,
+        height: 576,
+        fps: 75
+      },
+      {
+        width: 960,
+        height: 540,
+        fps: 60
+      },
+      {
+        width: 1280,
+        height: 720,
+        fps: 33.7
+      }
+    ]
+  },
+  {
+    level: "4",
+    maxBitrateMainTier: 12000,
+    maxBitrateHighTier: 30000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1280,
+        height: 720,
+        fps: 68
+      },
+      {
+        width: 1920,
+        height: 1080,
+        fps: 32
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 30
+      }
+    ]
+  },
+  {
+    level: "4.1",
+    maxBitrateMainTier: 20000,
+    maxBitrateHighTier: 50000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1280,
+        height: 720,
+        fps: 136
+      },
+      {
+        width: 1920,
+        height: 1080,
+        fps: 64
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 60
+      }
+    ]
+  },
+  {
+    level: "5",
+    maxBitrateMainTier: 25000,
+    maxBitrateHighTier: 1e5,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1920,
+        height: 1080,
+        fps: 128
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 120
+      },
+      {
+        width: 3840,
+        height: 2160,
+        fps: 32
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 30
+      }
+    ]
+  },
+  {
+    level: "5.1",
+    maxBitrateMainTier: 40000,
+    maxBitrateHighTier: 160000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 1920,
+        height: 1080,
+        fps: 256
+      },
+      {
+        width: 2048,
+        height: 1080,
+        fps: 240
+      },
+      {
+        width: 3840,
+        height: 2160,
+        fps: 64
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 60
+      }
+    ]
+  },
+  {
+    level: "5.2",
+    maxBitrateMainTier: 60000,
+    maxBitrateHighTier: 240000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 2048,
+        height: 1080,
+        fps: 300
+      },
+      {
+        width: 3840,
+        height: 2160,
+        fps: 128
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 120
+      }
+    ]
+  },
+  {
+    level: "6",
+    maxBitrateMainTier: 60000,
+    maxBitrateHighTier: 240000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 3840,
+        height: 2160,
+        fps: 128
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 120
+      },
+      {
+        width: 7680,
+        height: 4320,
+        fps: 32
+      },
+      {
+        width: 8192,
+        height: 4320,
+        fps: 30
+      }
+    ]
+  },
+  {
+    level: "6.1",
+    maxBitrateMainTier: 120000,
+    maxBitrateHighTier: 480000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 3840,
+        height: 2160,
+        fps: 256
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 240
+      },
+      {
+        width: 7680,
+        height: 4320,
+        fps: 64
+      },
+      {
+        width: 8192,
+        height: 4320,
+        fps: 60
+      }
+    ]
+  },
+  {
+    level: "6.2",
+    maxBitrateMainTier: 240000,
+    maxBitrateHighTier: 800000,
+    maxResolutionsAndFrameRates: [
+      {
+        width: 3840,
+        height: 2160,
+        fps: 512
+      },
+      {
+        width: 4096,
+        height: 2160,
+        fps: 480
+      },
+      {
+        width: 7680,
+        height: 4320,
+        fps: 128
+      },
+      {
+        width: 8192,
+        height: 4320,
+        fps: 120
+      }
+    ]
+  }
+];
+
+// src/choose-correct-hevc-profile.ts
+var chooseCorrectHevcProfile = ({
+  width,
+  height,
+  fps
+}) => {
+  const profile = hevcLevels.find((p) => {
+    return p.maxResolutionsAndFrameRates.some((max) => {
+      if (width > max.width) {
+        return false;
+      }
+      if (height > max.height) {
+        return false;
+      }
+      const fallbackFps = fps ?? 60;
+      return fallbackFps <= max.fps;
+    });
+  });
+  if (!profile) {
+    throw new Error(`No suitable HEVC profile found for ${width}x${height}@${fps}fps`);
+  }
+  return `hvc1.${1}.${0}.${"L"}${Math.round(Number(profile.level) * 30)}.${"b0"}`;
+};
+
+// src/get-codec-string.ts
+var getCodecStringForEncoder = ({
+  codec,
+  fps,
+  height,
+  width
+}) => {
+  if (codec === "h264") {
+    return chooseCorrectAvc1Profile({ fps, height, width });
+  }
+  if (codec === "h265") {
+    return chooseCorrectHevcProfile({ fps, height, width });
+  }
+  if (codec === "vp8") {
+    return "vp8";
+  }
+  if (codec === "vp9") {
+    return "vp09.00.10.08";
+  }
+  throw new Error(`Unknown codec: ${codec}`);
+};
+
 // src/video-encoder-config.ts
 var getVideoEncoderConfig = async ({
   codec,
@@ -1060,10 +1339,12 @@ var getVideoEncoderConfig = async ({
     return null;
   }
   const config = {
-    codec: codec === "h264" ? chooseCorrectAvc1Profile({ fps, height, width }) : codec === "vp9" ? "vp09.00.10.08" : codec,
+    codec: getCodecStringForEncoder({ codec, fps, height, width }),
     height,
     width,
-    bitrate: isSafari() ? 3000000 : undefined
+    bitrate: isSafari() ? 3000000 : undefined,
+    bitrateMode: codec === "vp9" && !isSafari() ? "quantizer" : undefined,
+    framerate: fps ?? undefined
   };
   const hardware = {
     ...config,
@@ -1222,6 +1503,29 @@ var generateOutputFilename = (source, container) => {
   return `${withoutExtension}.${container}`;
 };
 
+// src/get-available-containers.ts
+var availableContainers = ["webm", "mp4", "wav"];
+var getAvailableContainers = () => {
+  return availableContainers;
+};
+
+// src/get-available-video-codecs.ts
+var availableVideoCodecs = ["vp8", "vp9", "h264", "h265"];
+var getAvailableVideoCodecs = ({
+  container
+}) => {
+  if (container === "mp4") {
+    return ["h264", "h265"];
+  }
+  if (container === "webm") {
+    return ["vp8", "vp9"];
+  }
+  if (container === "wav") {
+    return [];
+  }
+  throw new Error(`Unsupported container: ${container}`);
+};
+
 // src/on-audio-track.ts
 import {
   MediaParserInternals as MediaParserInternals3
@@ -1375,7 +1679,8 @@ var makeAudioTrackHandler = ({
   const codecPrivate = audioOperation.audioCodec === "aac" ? MediaParserInternals3.createAacCodecPrivate({
     audioObjectType: 2,
     sampleRate: track.sampleRate,
-    channelConfiguration: track.numberOfChannels
+    channelConfiguration: track.numberOfChannels,
+    codecPrivate: null
   }) : null;
   const { trackNumber } = await state.addTrack({
     type: "audio",
@@ -1770,7 +2075,10 @@ var createVideoEncoder = ({
     }
     const keyFrame = framesProcessed % 40 === 0;
     encoder.encode(convertToCorrectVideoFrame({ videoFrame: frame, outputCodec }), {
-      keyFrame
+      keyFrame,
+      vp9: {
+        quantizer: 36
+      }
     });
     ioSynchronizer.inputItem(frame.timestamp, keyFrame);
     framesProcessed++;
@@ -2479,6 +2787,17 @@ var createAvccBox = (privateData) => {
   ]));
 };
 
+// src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-hvcc.ts
+var createHvccBox = (privateData) => {
+  if (!privateData) {
+    throw new Error("privateData is required");
+  }
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("hvcC"),
+    privateData
+  ]));
+};
+
 // src/create/iso-base-media/trak/mdia/minf/stbl/stsd/create-pasp.ts
 var createPasp = (x, y) => {
   return addSize(combineUint8Arrays([
@@ -2522,6 +2841,40 @@ var createAvc1Data = ({
   ]));
 };
 
+// src/create/iso-base-media/codec-specific/hvc1.ts
+var createHvc1Data = ({
+  compressorName,
+  depth,
+  height,
+  horizontalResolution,
+  hvccBox,
+  pasp,
+  verticalResolution,
+  width
+}) => {
+  return addSize(combineUint8Arrays([
+    stringsToUint8Array("hvc1"),
+    new Uint8Array([0, 0, 0, 0, 0, 0]),
+    new Uint8Array([0, 1]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(width),
+    numberTo16BitUIntOrInt(height),
+    setFixedPointSignedOrUnsigned1616Number(horizontalResolution),
+    setFixedPointSignedOrUnsigned1616Number(verticalResolution),
+    new Uint8Array([0, 0, 0, 0]),
+    numberTo16BitUIntOrInt(1),
+    stringToPascalString(compressorName),
+    numberTo16BitUIntOrInt(depth),
+    numberTo16BitUIntOrInt(-1),
+    hvccBox,
+    pasp
+  ]));
+};
+
 // src/create/iso-base-media/codec-specific/mp4a.ts
 var createMp4a = ({
   sampleRate,
@@ -2574,17 +2927,33 @@ var createMp4a = ({
 // src/create/iso-base-media/codec-specific/create-codec-specific-data.ts
 var createCodecSpecificData = (track) => {
   if (track.type === "video") {
-    return createAvc1Data({
-      avccBox: createAvccBox(track.codecPrivate),
-      compressorName: "WebCodecs",
-      depth: 24,
-      horizontalResolution: 72,
-      verticalResolution: 72,
-      height: track.height,
-      width: track.width,
-      pasp: createPasp(1, 1),
-      type: "avc1-data"
-    });
+    if (track.codec === "h264") {
+      return createAvc1Data({
+        avccBox: createAvccBox(track.codecPrivate),
+        compressorName: "WebCodecs",
+        depth: 24,
+        horizontalResolution: 72,
+        verticalResolution: 72,
+        height: track.height,
+        width: track.width,
+        pasp: createPasp(1, 1),
+        type: "avc1-data"
+      });
+    }
+    if (track.codec === "h265") {
+      return createHvc1Data({
+        hvccBox: createHvccBox(track.codecPrivate),
+        compressorName: "WebCodecs",
+        depth: 24,
+        horizontalResolution: 72,
+        verticalResolution: 72,
+        height: track.height,
+        width: track.width,
+        pasp: createPasp(1, 1),
+        type: "hvc1-data"
+      });
+    }
+    throw new Error("Unsupported codec specific data " + track.codec);
   }
   if (track.type === "audio") {
     return createMp4a({
@@ -3041,7 +3410,7 @@ var serializeTrack = ({
   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 createTrak({
@@ -3150,7 +3519,11 @@ var createIsoBaseMedia = async ({
     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 = {};
@@ -3266,8 +3639,8 @@ var createIsoBaseMedia = async ({
   };
   const waitForFinishPromises = [];
   return {
-    save: () => {
-      return w.save();
+    getBlob: () => {
+      return w.getBlob();
     },
     remove: async () => {
       await w.remove();
@@ -3308,7 +3681,7 @@ var createIsoBaseMedia = async ({
       await updateMoov();
       await updateMdatSize();
       MediaParserInternals6.Log.verbose(logLevel, "All write operations done. Waiting for finish...");
-      await w.waitForFinish();
+      await w.finish();
     }
   };
 };
@@ -3743,6 +4116,9 @@ var makeAudioCodecId = (codecId) => {
   if (codecId === "aac") {
     return "A_AAC";
   }
+  if (codecId === "ac3") {
+    return "A_AC3";
+  }
   if (codecId === "mp3") {
     return "A_MPEG/L3";
   }
@@ -3943,7 +4319,11 @@ var createMatroskaMedia = async ({
   progressTracker
 }) => {
   const header = 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 = makeMatroskaInfo({
     timescale
@@ -4076,8 +4456,8 @@ var createMatroskaMedia = async ({
         }
       });
     },
-    save: () => {
-      return w.save();
+    getBlob: async () => {
+      return w.getBlob();
     },
     remove: async () => {
       await w.remove();
@@ -4104,9 +4484,9 @@ var createMatroskaMedia = async ({
       });
       await updateSeekWrite();
       await w.write(createMatroskaCues(cues).bytes);
-      await w.waitForFinish();
       const segmentSize = w.getWrittenByteCount() - segmentOffset - matroskaToHex(matroskaElements.Segment).byteLength - MATROSKA_SEGMENT_MIN_VINT_WIDTH;
       await updateSegmentSize(segmentSize);
+      await w.finish();
     }
   };
 };
@@ -4133,7 +4513,11 @@ var createWav = async ({
   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([82, 73, 70, 70]));
   const sizePosition = w.getWrittenByteCount();
   await w.write(new Uint8Array([0, 0, 0, 0]));
@@ -4183,8 +4567,8 @@ var createWav = async ({
   };
   const waitForFinishPromises = [];
   return {
-    save: () => {
-      return w.save();
+    getBlob: () => {
+      return w.getBlob();
     },
     remove: () => {
       return w.remove();
@@ -4208,7 +4592,7 @@ var createWav = async ({
       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") {
@@ -4336,11 +4720,11 @@ var convertMedia = async function({
   if (userPassedAbortSignal?.aborted) {
     return Promise.reject(new error_cause_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" && availableContainers.indexOf(container) === -1) {
+    return Promise.reject(new TypeError(`Only the following values for "container" are supported currently: ${JSON.stringify(availableContainers)}`));
   }
-  if (videoCodec && videoCodec !== "vp8" && videoCodec !== "vp9") {
-    return Promise.reject(new TypeError('Only `videoCodec: "vp8"` and `videoCodec: "vp9"` are supported currently'));
+  if (videoCodec && availableVideoCodecs.indexOf(videoCodec) === -1) {
+    return Promise.reject(new TypeError(`Only the following values for "videoCodec" are supported currently: ${JSON.stringify(availableVideoCodecs)}`));
   }
   const { resolve, reject, getPromiseToImmediatelyReturn } = withResolversAndWaitForReturn();
   const controller = new AbortController;
@@ -4452,7 +4836,7 @@ var convertMedia = async function({
     return state.waitForFinish();
   }).then(() => {
     resolve({
-      save: state.save,
+      save: state.getBlob,
       remove: state.remove,
       finalState: throttledState.get()
     });
@@ -4487,26 +4871,6 @@ var getAvailableAudioCodecs = ({
   }
   throw new Error(`Unsupported container: ${container}`);
 };
-// src/get-available-containers.ts
-var availableContainers = ["webm", "mp4", "wav"];
-var getAvailableContainers = () => {
-  return availableContainers;
-};
-// src/get-available-video-codecs.ts
-var getAvailableVideoCodecs = ({
-  container
-}) => {
-  if (container === "mp4") {
-    return ["h264"];
-  }
-  if (container === "webm") {
-    return ["vp8", "vp9"];
-  }
-  if (container === "wav") {
-    return [];
-  }
-  throw new Error(`Unsupported container: ${container}`);
-};
 // src/index.ts
 var WebCodecsInternals = {
   rotateAndResizeVideoFrame,