Skip to content

🎥 Make videos programmatically with React

3.0 KB
Raw Blame
type Progress = {
	readonly peaks: Float32Array;
	readonly averageVolume: number | null;
	readonly completedPeaks: number;
	readonly totalPeaks: number;
	readonly final: boolean;
};

type WaveformPeakProcessorOptions = {
	readonly totalPeaks: number;
	readonly samplesPerPeak: number;
	readonly onProgress?: (progress: Progress) => void;
	readonly progressIntervalInMs: number;
	readonly now: () => number;
};

type WaveformPeakProcessor = {
	readonly peaks: Float32Array;
	readonly averageVolume: number | null;
	processSampleChunk: (
		floats: Float32Array,
		channels: number,
		sampleRate: number,
	) => void;
	finalize: () => void;
};

export const emitWaveformProgress = ({
	averageVolume,
	completedPeaks,
	final,
	onProgress,
	peaks,
	totalPeaks,
}: Progress & {
	readonly onProgress?: (progress: Progress) => void;
}) => {
	onProgress?.({
		averageVolume,
		peaks,
		completedPeaks,
		totalPeaks,
		final,
	});
};

export const createWaveformPeakProcessor = ({
	totalPeaks,
	samplesPerPeak,
	onProgress,
	progressIntervalInMs,
	now,
}: WaveformPeakProcessorOptions): WaveformPeakProcessor => {
	const peaks = new Float32Array(totalPeaks);
	let energy = 0;
	let duration = 0;
	let peakIndex = 0;
	let peakMax = 0;
	let sampleInPeak = 0;
	let lastProgressAt = 0;
	let lastProgressPeak = 0;

	const emitProgress = (force: boolean) => {
		const timestamp = now();
		if (!force && peakIndex === lastProgressPeak && sampleInPeak === 0) {
			return;
		}

		if (!force && timestamp - lastProgressAt < progressIntervalInMs) {
			return;
		}

		lastProgressAt = timestamp;
		lastProgressPeak = peakIndex;
		emitWaveformProgress({
			averageVolume:
				force && duration > 0 ? 10 * Math.log10(energy / duration) : null,
			peaks,
			completedPeaks: peakIndex,
			totalPeaks,
			final: force,
			onProgress,
		});
	};

	return {
		peaks,
		get averageVolume() {
			return duration > 0 ? 10 * Math.log10(energy / duration) : null;
		},
		processSampleChunk: (floats, channels, sampleRate) => {
			const frameCount = Math.floor(floats.length / Math.max(1, channels));

			for (let frame = 0; frame < frameCount; frame++) {
				// `f32` copies are interleaved, so timing advances per frame.
				let framePeak = 0;
				let frameEnergy = 0;
				for (let channel = 0; channel < channels; channel++) {
					const sampleIndex = frame * channels + channel;
					const abs = Math.abs(floats[sampleIndex] ?? 0);
					frameEnergy += abs * abs;
					if (abs > framePeak) {
						framePeak = abs;
					}
				}

				energy += frameEnergy / channels / sampleRate;
				duration += 1 / sampleRate;

				if (framePeak > peakMax) {
					peakMax = framePeak;
				}

				sampleInPeak++;

				if (sampleInPeak >= samplesPerPeak) {
					if (peakIndex < totalPeaks) {
						peaks[peakIndex] = peakMax;
					}

					peakIndex++;
					peakMax = 0;
					sampleInPeak = 0;
				}
			}

			emitProgress(false);
		},
		finalize: () => {
			if (sampleInPeak > 0 && peakIndex < totalPeaks) {
				peaks[peakIndex] = peakMax;
				peakIndex++;
			}

			emitProgress(true);
		},
	};
};