Create polished demo videos without editing skills. Mac/Windows/Linux
import React, { useMemo } from "react";
import type { SourceAudioTrackSettings } from "@/components/video-editor/audio/audioTypes";
import { resolveSourceTrackRoutingPolicy } from "@/lib/exporter/sourceTrackRoutingPolicy";
import type { AudioRegion, ClipRegion } from "../types";
import { findClipAtTimelineTime } from "../types";
import { isClipMutedById } from "./clipAudio";
import { useAudioPreviewSync } from "./useAudioPreviewSync";
import { useClipAudioSettingsController } from "./useClipAudioSettingsController";
import { useSourceAudioFallback } from "./useSourceAudioFallback";
function extractLocalPathFromMediaServerUrl(input: string | null | undefined): string | null {
if (!input) return null;
try {
const url = new URL(input);
const isLocalMediaServer =
(url.protocol === "http:" || url.protocol === "https:") &&
(url.hostname === "127.0.0.1" || url.hostname === "localhost") &&
url.pathname === "/video";
if (!isLocalMediaServer) return null;
return url.searchParams.get("path");
} catch {
return null;
}
}
interface UseVideoEditorAudioParams {
currentSourcePath: string | null;
selectedClipId: string | null;
clipRegions: ClipRegion[];
audioRegions: AudioRegion[];
sourceAudioTrackSettingsByClip: Record<string, SourceAudioTrackSettings>;
setSourceAudioTrackSettingsByClip: React.Dispatch<
React.SetStateAction<Record<string, SourceAudioTrackSettings>>
>;
defaultSourceAudioTrackSettings: SourceAudioTrackSettings;
setDefaultSourceAudioTrackSettings: React.Dispatch<
React.SetStateAction<SourceAudioTrackSettings>
>;
currentTime: number;
timelineTime: number;
duration: number;
isPlaying: boolean;
previewVolume: number;
sourceAudioFallbackRefreshKey?: number;
summarizeErrorMessage: (message: string) => string;
onSourceFallbackLoadError: (error: unknown) => void;
}
export function useVideoEditorAudio({
currentSourcePath,
selectedClipId,
clipRegions,
audioRegions,
sourceAudioTrackSettingsByClip,
setSourceAudioTrackSettingsByClip,
defaultSourceAudioTrackSettings,
setDefaultSourceAudioTrackSettings,
currentTime,
timelineTime,
duration,
isPlaying,
previewVolume,
sourceAudioFallbackRefreshKey = 0,
summarizeErrorMessage,
onSourceFallbackLoadError,
}: UseVideoEditorAudioParams) {
const fallbackLookupSourcePath = useMemo(
() => extractLocalPathFromMediaServerUrl(currentSourcePath) ?? currentSourcePath,
[currentSourcePath],
);
const { sourceAudioFallbackPaths, sourceAudioFallbackStartDelayMsByPath } =
useSourceAudioFallback({
currentSourcePath: fallbackLookupSourcePath,
refreshKey: sourceAudioFallbackRefreshKey,
summarizeErrorMessage,
});
const sourceTrackRoutingPolicy = useMemo(
() => resolveSourceTrackRoutingPolicy(currentSourcePath, sourceAudioFallbackPaths),
[currentSourcePath, sourceAudioFallbackPaths],
);
const previewSourceAudioFallbackPaths = sourceTrackRoutingPolicy.playbackPaths;
const shouldMutePreviewVideo = sourceTrackRoutingPolicy.muteEmbeddedPreview;
const activeClipIdAtCurrentTime = useMemo(
() => findClipAtTimelineTime(timelineTime * 1000, clipRegions)?.id ?? null,
[clipRegions, timelineTime],
);
const isCurrentClipMuted = useMemo(
() =>
activeClipIdAtCurrentTime === null ||
isClipMutedById(activeClipIdAtCurrentTime, clipRegions),
[activeClipIdAtCurrentTime, clipRegions],
);
const {
sourceAudioTrackMeta,
activeSourceAudioTrackSettings,
selectedClipSourceAudioTrackSettings,
getSourceAudioTrackSettingsForClip,
onSourceAudioTracksMetaChange,
onSelectedClipSourceAudioTrackVolumeChange,
onSelectedClipSourceAudioTrackNormalizeChange,
embeddedSourcePreviewGain,
getSourceTrackPreviewGain,
} = useClipAudioSettingsController({
selectedClipId,
activeClipId: activeClipIdAtCurrentTime,
sourceAudioTrackSettingsByClip,
setSourceAudioTrackSettingsByClip,
defaultSourceAudioTrackSettings,
setDefaultSourceAudioTrackSettings,
});
const { playSourceAudioPreview } = useAudioPreviewSync({
audioRegions,
previewVolume,
isPlaying,
currentTime,
timelineTime,
duration,
sourcePlaybackRate: findClipAtTimelineTime(timelineTime * 1000, clipRegions)?.speed ?? 1,
previewSourceAudioFallbackPaths,
sourceAudioFallbackStartDelayMsByPath,
sourceAudioResourceVersion: sourceAudioFallbackRefreshKey,
isCurrentClipMuted,
getSourceTrackPreviewGain,
onSourceFallbackLoadError,
});
return {
sourceAudioFallbackPaths,
sourceAudioFallbackStartDelayMsByPath,
previewSourceAudioFallbackPaths,
shouldMutePreviewVideo,
activeClipIdAtCurrentTime,
isCurrentClipMuted,
sourceAudioTrackMeta,
activeSourceAudioTrackSettings,
selectedClipSourceAudioTrackSettings,
playSourceAudioPreview,
getSourceAudioTrackSettingsForClip,
onSourceAudioTracksMetaChange,
onSelectedClipSourceAudioTrackVolumeChange,
onSelectedClipSourceAudioTrackNormalizeChange,
embeddedSourcePreviewGain,
getSourceTrackPreviewGain,
};
}