Skip to content

Create polished demo videos without editing skills. Mac/Windows/Linux

5.7 KB
Raw Blame
import React, { useCallback, useMemo, useState } from "react";
import type {
	SourceAudioTrackMeta,
	SourceAudioTrackSettings,
} from "@/components/video-editor/audio/audioTypes";

interface UseSourceAudioTrackSettingsParams {
	selectedClipId: string | null;
	activeClipId: string | null;
	sourceAudioTrackSettingsByClip: Record<string, SourceAudioTrackSettings>;
	setSourceAudioTrackSettingsByClip: React.Dispatch<
		React.SetStateAction<Record<string, SourceAudioTrackSettings>>
	>;
	defaultSourceAudioTrackSettings: SourceAudioTrackSettings;
	setDefaultSourceAudioTrackSettings: React.Dispatch<
		React.SetStateAction<SourceAudioTrackSettings>
	>;
}

export interface UseSourceAudioTrackSettingsResult {
	sourceAudioTrackMeta: SourceAudioTrackMeta;
	activeSourceAudioTrackSettings: SourceAudioTrackSettings;
	selectedClipSourceAudioTrackSettings: SourceAudioTrackSettings;
	getSourceAudioTrackSettingsForClip: (clipId: string | null) => SourceAudioTrackSettings;
	onSourceAudioTracksMetaChange: (tracks: SourceAudioTrackMeta) => void;
	onSelectedClipSourceAudioTrackVolumeChange: (id: string, volume: number) => void;
	onSelectedClipSourceAudioTrackNormalizeChange: (id: string, normalize: boolean) => void;
}

function isSameTrackMeta(left: SourceAudioTrackMeta, right: SourceAudioTrackMeta): boolean {
	if (left.length !== right.length) return false;
	for (let index = 0; index < left.length; index += 1) {
		const leftTrack = left[index];
		const rightTrack = right[index];
		if (!leftTrack || !rightTrack) return false;
		if (leftTrack.id !== rightTrack.id || leftTrack.label !== rightTrack.label) {
			return false;
		}
	}
	return true;
}

export function useSourceAudioTrackSettings({
	selectedClipId,
	activeClipId,
	sourceAudioTrackSettingsByClip,
	setSourceAudioTrackSettingsByClip,
	defaultSourceAudioTrackSettings,
	setDefaultSourceAudioTrackSettings,
}: UseSourceAudioTrackSettingsParams): UseSourceAudioTrackSettingsResult {
	const [sourceAudioTrackMeta, setSourceAudioTrackMeta] = useState<SourceAudioTrackMeta>([]);

	const activeSourceAudioTrackSettings = useMemo(() => {
		if (!activeClipId) {
			return defaultSourceAudioTrackSettings;
		}
		return {
			...defaultSourceAudioTrackSettings,
			...(sourceAudioTrackSettingsByClip[activeClipId] ?? {}),
		};
	}, [activeClipId, defaultSourceAudioTrackSettings, sourceAudioTrackSettingsByClip]);

	const selectedClipSourceAudioTrackSettings = useMemo(() => {
		if (!selectedClipId) {
			return defaultSourceAudioTrackSettings;
		}
		return {
			...defaultSourceAudioTrackSettings,
			...(sourceAudioTrackSettingsByClip[selectedClipId] ?? {}),
		};
	}, [defaultSourceAudioTrackSettings, selectedClipId, sourceAudioTrackSettingsByClip]);

	const onSourceAudioTracksMetaChange = useCallback(
		(tracks: SourceAudioTrackMeta) => {
			setSourceAudioTrackMeta((prev) => (isSameTrackMeta(prev, tracks) ? prev : tracks));
			setDefaultSourceAudioTrackSettings((prev) => {
				const next: SourceAudioTrackSettings = {};
				for (const track of tracks) {
					next[track.id] = prev[track.id] ?? { volume: 1, normalize: false };
				}
				const prevKeys = Object.keys(prev);
				const nextKeys = Object.keys(next);
				if (prevKeys.length !== nextKeys.length) {
					return next;
				}
				for (const key of nextKeys) {
					const prevSetting = prev[key];
					const nextSetting = next[key];
					if (!prevSetting || !nextSetting) {
						return next;
					}
					if (
						prevSetting.volume !== nextSetting.volume ||
						prevSetting.normalize !== nextSetting.normalize
					) {
						return next;
					}
				}
				return prev;
			});
		},
		[setDefaultSourceAudioTrackSettings],
	);

	const getSourceAudioTrackSettingsForClip = useCallback(
		(clipId: string | null): SourceAudioTrackSettings => {
			if (!clipId) {
				return defaultSourceAudioTrackSettings;
			}
			return {
				...defaultSourceAudioTrackSettings,
				...(sourceAudioTrackSettingsByClip[clipId] ?? {}),
			};
		},
		[defaultSourceAudioTrackSettings, sourceAudioTrackSettingsByClip],
	);

	const onSelectedClipSourceAudioTrackVolumeChange = useCallback(
		(id: string, volume: number) => {
			if (!selectedClipId) return;
			setSourceAudioTrackSettingsByClip((prev) => {
				const prevClip = prev[selectedClipId] ?? defaultSourceAudioTrackSettings;
				const nextVolume = Number.isFinite(volume)
					? Math.max(0, Math.min(1, volume))
					: (prevClip[id]?.volume ?? 1);
				const prevNormalize = prevClip[id]?.normalize ?? false;
				if (
					prevClip[id]?.volume === nextVolume &&
					prevClip[id]?.normalize === prevNormalize
				) {
					return prev;
				}
				return {
					...prev,
					[selectedClipId]: {
						...prevClip,
						[id]: {
							volume: nextVolume,
							normalize: prevNormalize,
						},
					},
				};
			});
		},
		[defaultSourceAudioTrackSettings, selectedClipId, setSourceAudioTrackSettingsByClip],
	);

	const onSelectedClipSourceAudioTrackNormalizeChange = useCallback(
		(id: string, normalize: boolean) => {
			if (!selectedClipId) return;
			setSourceAudioTrackSettingsByClip((prev) => {
				const prevClip = prev[selectedClipId] ?? defaultSourceAudioTrackSettings;
				const prevVolume = prevClip[id]?.volume ?? 1;
				if (prevClip[id]?.normalize === normalize) {
					return prev;
				}
				return {
					...prev,
					[selectedClipId]: {
						...prevClip,
						[id]: {
							volume: prevVolume,
							normalize,
						},
					},
				};
			});
		},
		[defaultSourceAudioTrackSettings, selectedClipId, setSourceAudioTrackSettingsByClip],
	);

	return {
		sourceAudioTrackMeta,
		activeSourceAudioTrackSettings,
		selectedClipSourceAudioTrackSettings,
		getSourceAudioTrackSettingsForClip,
		onSourceAudioTracksMetaChange,
		onSelectedClipSourceAudioTrackVolumeChange,
		onSelectedClipSourceAudioTrackNormalizeChange,
	};
}