Skip to content

🎥 Make videos programmatically with React

13.3 KB
Raw Blame
import {
  createBrowserBundleRuntime,
  createBrowserCompositionObserver,
  type BrowserComposition,
} from "@remotion/browser-bundler/runtime";
import {
  Canvas,
  createCanvasController,
  type CanvasSequencePropsChangeHandler,
  type CanvasSequencePropStatusResolver,
} from "@remotion/sdk";
import type { PlayerRef } from "@remotion/player";
import {
  canRenderMediaOnWeb,
  renderMediaOnWeb,
  renderStillOnWeb,
} from "@remotion/web-renderer";
import React, { useCallback, useEffect, useSyncExternalStore } from "react";
import { createRoot } from "react-dom/client";
import type {
  CreatePreviewHost,
  PreviewCompositionSelection,
  PreviewKeyEvent,
  PreviewOptions,
} from "./bridge";

type PreviewState = {
  root: React.FC | null;
  selection: PreviewCompositionSelection | null;
  composition: BrowserComposition | null;
  // The revision that was current when `composition` was resolved.
  compositionRevision: number;
  options: PreviewOptions;
  revision: number;
  player: PlayerRef | null;
};

const defaultOptions: PreviewOptions = {
  showOutlines: true,
  checkerboard: false,
  zoom: "fit",
  loop: true,
  playbackRate: 1,
  inFrame: null,
  outFrame: null,
};

const createPreviewStore = () => {
  let state: PreviewState = {
    root: null,
    selection: null,
    composition: null,
    compositionRevision: 0,
    options: defaultOptions,
    revision: 0,
    player: null,
  };
  const listeners = new Set<() => void>();
  const emit = () => {
    for (const listener of listeners) {
      listener();
    }
  };

  return {
    getState: () => state,
    setState: (patch: Partial<PreviewState>) => {
      state = { ...state, ...patch };
      emit();
    },
    subscribe: (listener: () => void) => {
      listeners.add(listener);
      return () => {
        listeners.delete(listener);
      };
    },
  };
};

type PreviewStore = ReturnType<typeof createPreviewStore>;

const checkerboard =
  "repeating-conic-gradient(#1c2029 0% 25%, #12151c 0% 50%) 50% / 28px 28px";

const PreviewApp: React.FC<{
  readonly store: PreviewStore;
  readonly controller: ReturnType<typeof createCanvasController>;
  readonly onReady: (revision: number) => void;
  readonly onSequencePropsChange: CanvasSequencePropsChangeHandler;
  readonly getSequencePropStatuses: CanvasSequencePropStatusResolver;
}> = ({
  store,
  controller,
  onReady,
  onSequencePropsChange,
  getSequencePropStatuses,
}) => {
  const state = useSyncExternalStore(
    store.subscribe,
    store.getState,
    store.getState,
  );
  const { composition, options, compositionRevision } = state;

  useEffect(() => {
    if (composition) {
      onReady(compositionRevision);
    }
  }, [composition, onReady, compositionRevision]);

  // A stable ref callback: a new function on every render would be re-invoked
  // by React on each commit and loop through the store.
  const setPlayer = useCallback(
    (player: PlayerRef | null) => {
      if (store.getState().player !== player) {
        store.setState({ player });
      }
    },
    [store],
  );

  if (!composition) {
    return (
      <div
        className="preview-loading"
        style={{
          position: "absolute",
          inset: 0,
          display: "flex",
          alignItems: "center",
          justifyContent: "center",
          fontSize: 12,
        }}
      >
        Waiting for the first compilation…
      </div>
    );
  }

  const fit = options.zoom === "fit";
  const zoom = typeof options.zoom === "number" ? options.zoom : 1;

  return (
    <div
      style={{
        position: "absolute",
        inset: 0,
        overflow: fit ? "hidden" : "auto",
        background: options.checkerboard ? checkerboard : "#050608",
      }}
    >
      <div
        style={
          fit
            ? {
                position: "absolute",
                inset: 20,
              }
            : {
                minWidth: "100%",
                minHeight: "100%",
                display: "flex",
                alignItems: "center",
                justifyContent: "center",
                boxSizing: "border-box",
                padding: 40,
              }
        }
      >
        <Canvas
          key={composition.id}
          ref={setPlayer}
          controller={controller}
          showOutlines={options.showOutlines}
          onSequencePropsChange={onSequencePropsChange}
          getSequencePropStatuses={getSequencePropStatuses}
          component={composition.component}
          inputProps={composition.props}
          compositionWidth={composition.width}
          compositionHeight={composition.height}
          fps={composition.fps}
          durationInFrames={composition.durationInFrames}
          controls={false}
          loop={options.loop}
          playbackRate={options.playbackRate}
          inFrame={options.inFrame}
          outFrame={options.outFrame}
          spaceKeyToPlayOrPause={false}
          clickToPlay={false}
          doubleClickToFullscreen={false}
          acknowledgeRemotionLicense
          errorFallback={({ error }) => (
            <div
              role="alert"
              style={{
                position: "absolute",
                inset: 0,
                display: "flex",
                alignItems: "center",
                justifyContent: "center",
                padding: 32,
                color: "#fca5a5",
                backgroundColor: "#1a0f12",
                fontFamily: "monospace",
                fontSize: 14,
                whiteSpace: "pre-wrap",
              }}
            >
              {error.message}
            </div>
          )}
          style={
            fit
              ? { width: "100%", height: "100%" }
              : {
                  width: composition.width * zoom,
                  height: composition.height * zoom,
                  flexShrink: 0,
                }
          }
        />
      </div>
    </div>
  );
};

const isEditableTarget = (target: EventTarget | null) =>
  target instanceof HTMLElement &&
  (target.isContentEditable ||
    target.tagName === "INPUT" ||
    target.tagName === "SELECT" ||
    target.tagName === "TEXTAREA");

export const createPreviewHost: CreatePreviewHost = ({
  onError,
  onKeyDown,
  onSequencePropsChange,
  getSequencePropStatuses,
}) => {
  const container = document.getElementById("preview-root");
  if (!container) {
    throw new Error("The preview container was not found.");
  }

  const store = createPreviewStore();
  const controller = createCanvasController();
  const runtime = createBrowserBundleRuntime();
  let disposed = false;
  let waiters: {
    resolve: (composition: BrowserComposition) => void;
    reject: (error: Error) => void;
    timeout: number;
  }[] = [];

  const settleWaiters = (
    result:
      | { type: "resolved"; composition: BrowserComposition }
      | { type: "rejected"; error: Error },
  ) => {
    const pending = waiters;
    waiters = [];
    for (const waiter of pending) {
      window.clearTimeout(waiter.timeout);
      if (result.type === "resolved") {
        waiter.resolve(result.composition);
      } else {
        waiter.reject(result.error);
      }
    }
  };

  const reportError = (error: unknown) => {
    if (disposed) {
      return;
    }

    // React does not log errors itself when custom error handlers are set.
    console.error(error);
    const message = error instanceof Error ? error.message : String(error);
    settleWaiters({ type: "rejected", error: new Error(message) });
    onError(message);
  };

  const onReady = (readyRevision: number) => {
    const { composition, revision } = store.getState();
    if (composition && readyRevision === revision) {
      settleWaiters({ type: "resolved", composition });
    }
  };

  const root = createRoot(container, {
    onCaughtError: reportError,
    onUncaughtError: reportError,
  });
  root.render(
    <PreviewApp
      store={store}
      controller={controller}
      onReady={onReady}
      onSequencePropsChange={onSequencePropsChange}
      getSequencePropStatuses={getSequencePropStatuses}
    />,
  );

  const observer = createBrowserCompositionObserver({
    onChange: (composition) => {
      store.setState({
        composition,
        compositionRevision: store.getState().revision,
      });
    },
    onError: reportError,
  });

  const resolveSelection = (selection: PreviewCompositionSelection) => {
    const { root: registeredRoot } = store.getState();
    if (!registeredRoot) {
      throw new Error("Compile the project before selecting a composition.");
    }

    const revision = store.getState().revision + 1;
    store.setState({ revision, selection });
    return new Promise<BrowserComposition>((resolve, reject) => {
      waiters.push({
        resolve,
        reject,
        timeout: window.setTimeout(() => {
          reportError(
            new Error(
              `Timed out while resolving the composition "${selection.compositionId}".`,
            ),
          );
        }, 30_000),
      });
      observer.update({
        root: registeredRoot,
        compositionId: selection.compositionId,
        inputProps: selection.inputProps,
      });
    });
  };

  const keyListener = (event: KeyboardEvent) => {
    const normalized: PreviewKeyEvent = {
      key: event.key,
      code: event.code,
      shiftKey: event.shiftKey,
      metaKey: event.metaKey,
      ctrlKey: event.ctrlKey,
      altKey: event.altKey,
      repeat: event.repeat,
      isEditable: isEditableTarget(event.target),
    };
    if (onKeyDown(normalized)) {
      event.preventDefault();
      event.stopPropagation();
    }
  };
  window.addEventListener("keydown", keyListener);

  const dispose = () => {
    if (disposed) {
      return;
    }

    disposed = true;
    window.removeEventListener("pagehide", dispose);
    window.removeEventListener("keydown", keyListener);
    settleWaiters({
      type: "rejected",
      error: new Error("The preview was disposed."),
    });
    try {
      root.unmount();
    } finally {
      try {
        observer.dispose();
      } finally {
        runtime.dispose();
      }
    }
  };
  window.addEventListener("pagehide", dispose);

  const getCompositionForRender = () => {
    const { composition, player } = store.getState();
    if (!composition) {
      throw new Error("There is no composition to render yet.");
    }

    player?.pause();
    return composition;
  };

  return {
    controller,
    applyBundle: async (bundle) => {
      if (disposed) {
        throw new Error("The preview was disposed.");
      }

      const registeredRoot = await runtime.applyBundle(bundle);
      if (disposed) {
        throw new Error("The preview was disposed.");
      }

      store.setState({ root: registeredRoot });
      const { selection } = store.getState();
      if (selection) {
        await resolveSelection(selection);
      }
    },
    selectComposition: (selection) => {
      if (disposed) {
        return Promise.reject(new Error("The preview was disposed."));
      }

      return resolveSelection(selection);
    },
    setOptions: (options) => {
      store.setState({
        options: { ...store.getState().options, ...options },
      });
    },
    getPlayer: () => store.getState().player,
    subscribe: store.subscribe,
    getSnapshot: () => {
      const { composition, player } = store.getState();
      return { composition, playerReady: player !== null };
    },
    canRenderMedia: async (request) => {
      const { composition } = store.getState();
      if (!composition) {
        throw new Error("There is no composition to render yet.");
      }

      return canRenderMediaOnWeb({
        container: request.container,
        videoCodec: request.videoCodec,
        width: Math.round(composition.width * request.scale),
        height: Math.round(composition.height * request.scale),
        muted: request.muted,
        videoBitrate: request.videoBitrate,
      });
    },
    render: async (request, { onProgress, signal }) => {
      const composition = getCompositionForRender();
      const compositionForRenderer = {
        component: composition.component,
        id: composition.id,
        width: composition.width,
        height: composition.height,
        fps: composition.fps,
        durationInFrames: composition.durationInFrames,
      };

      if (request.kind === "still") {
        const still = await renderStillOnWeb({
          composition: compositionForRenderer,
          inputProps: composition.props,
          frame: request.frame,
          scale: request.scale,
          signal,
        });
        const blob = await still.blob({ format: request.format });
        return {
          url: URL.createObjectURL(blob),
          sizeInBytes: blob.size,
          mimeType: blob.type,
        };
      }

      const { getBlob } = await renderMediaOnWeb({
        composition: compositionForRenderer,
        inputProps: composition.props,
        container: request.container,
        videoCodec: request.videoCodec,
        videoBitrate: request.videoBitrate,
        scale: request.scale,
        muted: request.muted,
        frameRange: request.frameRange,
        signal,
        onProgress: (progress) => {
          onProgress({
            progress: progress.progress,
            renderedFrames: progress.renderedFrames,
            encodedFrames: progress.encodedFrames,
          });
        },
      });
      const blob = await getBlob();
      return {
        url: URL.createObjectURL(blob),
        sizeInBytes: blob.size,
        mimeType: blob.type,
      };
    },
    dispose,
  };
};