Skip to content

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

3.7 KB
Raw Blame
import { SOURCE_AUDIO_NORMALIZE_GAIN } from "@/components/video-editor/audio/audioTypes";
import type { AudioRegion } from "@/components/video-editor/types";
import { getSourceTrackIdFromPath } from "./audioProcessorShared";
import type { SourceTrackId } from "./audioProcessorShared";
import { resolveSourceAudioFallbackPaths } from "./sourceAudioFallback";

export { getSourceTrackIdFromPath };
export type { SourceTrackId };

export type ResolvedAudioTrackKind = "user" | "system" | "mic" | "mixed" | "embedded";

export interface ResolvedAudioTrack {
	id: string;
	kind: ResolvedAudioTrackKind;
	sourceRef: {
		path: string;
		startDelayMs: number;
	};
	gain: number;
	timelineBinding: {
		startMs: number;
		endMs: number;
	};
}

export interface ResolvedAudioPlan {
	hasEmbeddedSourceAudio: boolean;
	pathsByTrack: Partial<Record<SourceTrackId, string>>;
	playbackPaths: string[];
	muteEmbeddedPreview: boolean;
	includeEmbeddedInExport: boolean;
	tracks: ResolvedAudioTrack[];
	masterGain: number;
}

function clampGain(value: number, max: number) {
	if (!Number.isFinite(value)) return 1;
	return Math.max(0, Math.min(max, value));
}

export function buildResolvedAudioPlan(input: {
	videoResource: string | null | undefined;
	sourceAudioFallbackPaths: string[] | null | undefined;
	audioRegions?: AudioRegion[];
	sourceTrackGainById?: Partial<Record<SourceTrackId, number>>;
	embeddedGain?: number;
	masterGain?: number;
}): ResolvedAudioPlan {
	const { hasEmbeddedSourceAudio, externalAudioPaths } = resolveSourceAudioFallbackPaths(
		input.videoResource,
		input.sourceAudioFallbackPaths,
	);

	const pathsByTrack: Partial<Record<SourceTrackId, string>> = {};
	for (const path of externalAudioPaths) {
		const trackId = getSourceTrackIdFromPath(path);
		if (!pathsByTrack[trackId]) {
			pathsByTrack[trackId] = path;
		}
	}

	const hasDedicatedTracks = Boolean(pathsByTrack.system || pathsByTrack.mic);
	const playbackPaths: string[] = [];
	if (pathsByTrack.system) playbackPaths.push(pathsByTrack.system);
	if (pathsByTrack.mic) playbackPaths.push(pathsByTrack.mic);
	if (!hasDedicatedTracks && pathsByTrack.mixed) playbackPaths.push(pathsByTrack.mixed);

	const includeEmbeddedInExport = !pathsByTrack.system && !pathsByTrack.mixed;
	const resolvedRegions = (input.audioRegions ?? [])
		.slice()
		.sort((a, b) => a.startMs - b.startMs);
	const tracks: ResolvedAudioTrack[] = resolvedRegions.map((region) => ({
		id: `user:${region.id}`,
		kind: "user",
		sourceRef: {
			path: region.audioPath,
			startDelayMs: 0,
		},
		gain: clampGain(region.volume * (region.normalize ? SOURCE_AUDIO_NORMALIZE_GAIN : 1), 1),
		timelineBinding: {
			startMs: Math.max(0, region.startMs),
			endMs: Math.max(0, region.endMs),
		},
	}));

	for (const audioPath of playbackPaths) {
		const trackId = getSourceTrackIdFromPath(audioPath);
		tracks.push({
			id: `${trackId}:${audioPath}`,
			kind: trackId,
			sourceRef: {
				path: audioPath,
				startDelayMs: 0,
			},
			gain: clampGain(input.sourceTrackGainById?.[trackId] ?? 1, 2),
			timelineBinding: {
				startMs: 0,
				endMs: Number.POSITIVE_INFINITY,
			},
		});
	}

	if (hasEmbeddedSourceAudio && input.videoResource) {
		tracks.push({
			id: `embedded:${input.videoResource}`,
			kind: "embedded",
			sourceRef: {
				path: input.videoResource,
				startDelayMs: 0,
			},
			gain: clampGain(input.embeddedGain ?? input.sourceTrackGainById?.mixed ?? 1, 2),
			timelineBinding: {
				startMs: 0,
				endMs: Number.POSITIVE_INFINITY,
			},
		});
	}

	return {
		hasEmbeddedSourceAudio,
		pathsByTrack,
		playbackPaths,
		muteEmbeddedPreview: hasDedicatedTracks && !includeEmbeddedInExport,
		includeEmbeddedInExport,
		tracks,
		masterGain: clampGain(input.masterGain ?? 1, 1),
	};
}