Skip to content

🎥 Make videos programmatically with React

11.9 KB
Raw Blame
import { useCallback, useMemo, useState } from "react";
import { WEBCAM_PREFIX } from "../config/cameras";
import { CropIndicator } from "./CropIndicator";
import { PrefixLabel } from "./PrefixAndResolution";
import { RecordingStatus } from "./RecordButton";
import { ResolutionLimiter } from "./ResolutionLimiter";
import { ToggleRotate } from "./Rotate";
import { ResolutionAndFps, Stream } from "./Stream";
import { ToggleCrop } from "./ToggleCrop";
import { ToggleMirror } from "./ToggleMirror";
import { useDevices } from "./WaitingForDevices";
import { ClearCurrentVideo } from "./components/ClearCurrentVideo";
import { CurrentAudio } from "./components/CurrentAudio";
import { CurrentVideo } from "./components/CurrentVideo";
import { Divider } from "./components/Divider";
import { StreamPicker, getDeviceLabel } from "./components/StreamPicker";
import { VolumeMeter } from "./components/VolumeMeter";
import { canRotateCamera } from "./helpers/can-rotate-camera";
import {
  MaxResolution,
  getMaxResolutionOfDevice,
} from "./helpers/get-max-resolution-of-device";
import {
  SizeConstraint,
  getSelectedVideoSource,
} from "./helpers/get-selected-video-source";
import { Prefix } from "./helpers/prefixes";
import { setPreferredDeviceForPrefix } from "./preferred-device-localstorage";
import { getPreferredResolutionForDevice } from "./preferred-resolution";
import { useMediaSources } from "./state/media-sources";
import { visibleByDefault } from "./state/visible-views";
const viewContainer: React.CSSProperties = {
  display: "flex",
  flexDirection: "column",
  margin: 10,
  backgroundColor: "#242424",
  borderRadius: 10,
  overflow: "hidden",
  width: "100%",
  height: "100%",
  maxHeight: "100%",
  maxWidth: "100%",
  position: "relative",
};

const topBar: React.CSSProperties = {
  display: "flex",
  alignItems: "center",
  paddingLeft: 10,
};

const streamViewport: React.CSSProperties = {
  flex: 1,
  position: "relative",
};

const localStorageKey = "showCropIndicator";
const mirrorLocalStorageKey = "mirrorCamera";

const InnerRecordingView: React.FC<{
  prefix: Prefix;
  recordingStatus: RecordingStatus;
}> = ({ prefix, recordingStatus }) => {
  const { mediaSources, setAudioDevice, setVideoDevice } = useMediaSources();
  const mediaStream = mediaSources[prefix];

  const initialCropIndicatorState = useMemo(() => {
    return (
      localStorage.getItem(localStorageKey) === "true" &&
      prefix === WEBCAM_PREFIX
    );
  }, [prefix]);

  const [showCropIndicator, setShowCropIndicator] = useState(
    initialCropIndicatorState,
  );

  const [showPickerPreference, setShowPicker] = useState(
    () => !mediaStream.videoDevice && !mediaStream.audioDevice,
  );

  const recordAudio = prefix === WEBCAM_PREFIX;
  const [resolution, setResolution] = useState<ResolutionAndFps | null>(null);
  const [preferPortrait, setPreferPortrait] = useState(false);

  const initialMirrorState = useMemo(() => {
    if (prefix !== WEBCAM_PREFIX) {
      return false;
    }
    // Default to mirrored for webcam, but respect user's saved preference
    const savedPreference = localStorage.getItem(mirrorLocalStorageKey);
    if (savedPreference !== null) {
      return savedPreference === "true";
    }
    // Default to true for webcam, false for other sources
    return prefix === WEBCAM_PREFIX;
  }, [prefix]);

  const [mirrorCamera, setMirrorCamera] = useState(initialMirrorState);

  const [sizeConstraint, setSizeConstraint] = useState<SizeConstraint>(() =>
    getPreferredResolutionForDevice(mediaStream.videoDevice),
  );

  const onToggleCrop = useCallback(() => {
    setShowCropIndicator((prev) => {
      window.localStorage.setItem(localStorageKey, String(!prev));
      return !prev;
    });
  }, []);

  const onToggleRotate = useCallback(() => {
    setPreferPortrait((prev) => {
      return !prev;
    });
  }, []);

  const onToggleMirror = useCallback(() => {
    setMirrorCamera((prev) => {
      const newValue = !prev;
      window.localStorage.setItem(mirrorLocalStorageKey, String(newValue));
      return newValue;
    });
  }, []);

  const selectScreenWithoutAudio = useCallback(async () => {
    setVideoDevice(prefix, "display-without-audio");
    if (recordAudio && !mediaStream.audioDevice) {
      return;
    }
    setShowPicker(false);
  }, [mediaStream.audioDevice, prefix, recordAudio, setVideoDevice]);
  const selectScreenWithAudio = useCallback(async () => {
    setVideoDevice(prefix, "display-with-audio");
    setShowPicker(false);
  }, [prefix, setVideoDevice]);

  const devices = useDevices();

  const activeVideoDevice = useMemo(() => {
    return devices.find((d) => d.deviceId === mediaStream.videoDevice);
  }, [devices, mediaStream.videoDevice]);
  const activeAudioDevice = useMemo(() => {
    return devices.find((d) => d.deviceId === mediaStream.audioDevice);
  }, [devices, mediaStream.audioDevice]);

  const maxResolution = useMemo(() => {
    if (!activeVideoDevice) {
      return null;
    }

    return getMaxResolutionOfDevice(activeVideoDevice);
  }, [activeVideoDevice]);

  const selectedVideoSource = useMemo(() => {
    if (mediaStream.videoDevice === "display-without-audio") {
      return { type: "display-without-audio" as const };
    }
    if (mediaStream.videoDevice === "display-with-audio") {
      return { type: "display-with-audio" as const };
    }

    if (!activeVideoDevice) {
      return null;
    }

    return getSelectedVideoSource({
      device: activeVideoDevice,
      resolutionConstraint: sizeConstraint,
      maxResolution,
    });
  }, [
    activeVideoDevice,
    maxResolution,
    mediaStream.videoDevice,
    sizeConstraint,
  ]);

  const videoDeviceLabel = useMemo(() => {
    if (mediaStream.videoDevice === "display-without-audio") {
      return "Screen Share";
    }
    if (mediaStream.videoDevice === "display-with-audio") {
      return "Screen Share with audio";
    }

    if (!activeVideoDevice) {
      return null;
    }

    return getDeviceLabel(activeVideoDevice);
  }, [activeVideoDevice, mediaStream.videoDevice]);

  const audioDeviceLabel = useMemo(() => {
    if (!activeAudioDevice) {
      return null;
    }

    return getDeviceLabel(activeAudioDevice);
  }, [activeAudioDevice]);

  const cameraRotateable = useMemo(() => {
    return canRotateCamera({
      selectedSource: selectedVideoSource,
      preferPortrait,
      resolution,
    });
  }, [preferPortrait, resolution, selectedVideoSource]);

  const onPickVideo = useCallback(
    (device: MediaDeviceInfo) => {
      setVideoDevice(prefix, device.deviceId);
      setPreferredDeviceForPrefix(prefix, "video", device.deviceId);
      if (recordAudio && !mediaStream.audioDevice) {
        return;
      }
      setShowPicker(false);
    },
    [mediaStream.audioDevice, prefix, recordAudio, setVideoDevice],
  );

  const onPickAudio = useCallback(
    (device: MediaDeviceInfo) => {
      setAudioDevice(prefix, device.deviceId);
      setPreferredDeviceForPrefix(prefix, "audio", device.deviceId);
      if (!mediaStream.videoDevice) {
        return;
      }
      setShowPicker(false);
    },
    [mediaStream.videoDevice, prefix, setAudioDevice],
  );

  const clear = useCallback(() => {
    setVideoDevice(prefix, null);
    setAudioDevice(prefix, null);
    setPreferredDeviceForPrefix(prefix, "video", null);
    setShowPicker(true);
    setResolution(null);
  }, [prefix, setAudioDevice, setVideoDevice]);

  const [resolutionLimiterOpen, setResolutionLimiterOpen] = useState(false);

  const canShowResolutionLimiter = Boolean(
    selectedVideoSource?.type === "display-without-audio" ||
      selectedVideoSource?.type === "display-with-audio"
      ? false
      : videoDeviceLabel && activeVideoDevice && maxResolution,
  );

  const hasSelectedVideoOrAudio = Boolean(
    mediaStream.videoDevice || mediaStream.audioDevice,
  );

  const showPicker =
    showPickerPreference && recordingStatus.type !== "recording";
  const togglePicker = useCallback(() => {
    setShowPicker((prev) => !prev);
  }, []);

  return (
    <div
      style={viewContainer}
      data-recording={Boolean(
        recordingStatus.type === "recording" &&
        hasSelectedVideoOrAudio &&
        mediaStream.streamState.type === "loaded",
      )}
      className="outline-red-600 outline-0 data-[recording=true]:outline-2 outline"
    >
      <div style={topBar}>
        <div style={{ width: 10 }}></div>
        <PrefixLabel prefix={prefix} />
        <div style={{ width: 15 }}></div>
        <Divider></Divider>
        <CurrentVideo
          resolution={resolution}
          label={videoDeviceLabel ?? "No video selected"}
          isScreenshare={
            selectedVideoSource?.type === "display-without-audio" ||
            selectedVideoSource?.type === "display-with-audio"
          }
          onClick={togglePicker}
          setResolutionLimiterOpen={setResolutionLimiterOpen}
          canShowResolutionLimiter={canShowResolutionLimiter}
          disabled={recordingStatus.type === "recording"}
        ></CurrentVideo>
        {selectedVideoSource && recordingStatus.type !== "recording" ? (
          <ClearCurrentVideo onClick={clear} />
        ) : null}
        {prefix === WEBCAM_PREFIX ? (
          <>
            <Divider></Divider>
            <CurrentAudio
              disabled={recordingStatus.type === "recording"}
              onClick={togglePicker}
              label={audioDeviceLabel}
            />
          </>
        ) : null}
        {prefix === WEBCAM_PREFIX ? (
          <ToggleCrop
            pressed={showCropIndicator}
            onPressedChange={onToggleCrop}
          />
        ) : null}
        {prefix === WEBCAM_PREFIX &&
        mediaStream.videoDevice !== "display-without-audio" &&
        mediaStream.videoDevice !== "display-with-audio" &&
        activeVideoDevice ? (
          <ToggleMirror
            pressed={mirrorCamera}
            onPressedChange={onToggleMirror}
            disabled={recordingStatus.type === "recording"}
          />
        ) : null}
        {cameraRotateable ? (
          <ToggleRotate
            pressed={preferPortrait}
            onPressedChange={onToggleRotate}
            disabled={recordingStatus.type === "recording"}
          />
        ) : null}
      </div>
      {prefix === WEBCAM_PREFIX ? (
        <VolumeMeter mediaStream={mediaStream.streamState} />
      ) : null}
      <div style={streamViewport}>
        <Stream
          selectedAudioSource={mediaStream.audioDevice}
          selectedVideoSource={selectedVideoSource}
          recordAudio={recordAudio}
          setResolution={setResolution}
          prefix={prefix}
          preferPortrait={preferPortrait}
          mirror={mirrorCamera}
          clear={clear}
        />
        {showCropIndicator && resolution && !showPicker ? (
          <CropIndicator resolution={resolution} />
        ) : null}
        {showPicker ? (
          <StreamPicker
            onPickVideo={onPickVideo}
            onPickAudio={onPickAudio}
            canSelectAudio={recordAudio}
            onPickScreenWithoutAudio={selectScreenWithoutAudio}
            onPickScreenWithAudio={selectScreenWithAudio}
            selectedAudioDevice={mediaStream.audioDevice}
            selectedVideoDevice={mediaStream.videoDevice}
            clear={clear}
          />
        ) : null}
        {canShowResolutionLimiter ? (
          <ResolutionLimiter
            sizeConstraint={sizeConstraint}
            setSizeConstraint={setSizeConstraint}
            maxResolution={maxResolution as MaxResolution}
            deviceName={videoDeviceLabel as string}
            deviceId={(activeVideoDevice as MediaDeviceInfo).deviceId}
            open={resolutionLimiterOpen}
            setOpen={setResolutionLimiterOpen}
          />
        ) : null}
      </div>
    </div>
  );
};

export const RecordingView: React.FC<{
  prefix: Prefix;
  recordingStatus: RecordingStatus;
  showAllViews: boolean;
}> = ({ prefix, recordingStatus, showAllViews }) => {
  if (!visibleByDefault[prefix] && !showAllViews) {
    return null;
  }

  return (
    <InnerRecordingView prefix={prefix} recordingStatus={recordingStatus} />
  );
};