Skip to content

🎥 Make videos programmatically with React

3.2 KB
Raw Blame
import React from 'react';
import {Internals, type LogLevel} from 'remotion';
import {makeAudioManager} from './audio-extraction/audio-manager';
import {makeSinkManager} from './get-sink';
import {getMaxVideoCacheSize} from './max-cache-size';
import {makeSerializedQueue} from './serialized-queue';
import {makeKeyframeManager} from './video-extraction/keyframe-manager';

// Frames can be out of order, but we don't expect them to be more than 0.2 seconds out of order
export const getSafeWindowOfMonotonicity = (fps: number) => (0.2 * 30) / fps;

export const makeMediaCache = () => {
	const sinkManager = makeSinkManager();
	const managerInstances: {
		keyframe: ReturnType<typeof makeKeyframeManager> | null;
		audio: ReturnType<typeof makeAudioManager> | null;
	} = {
		keyframe: null,
		audio: null,
	};
	const getCacheStats = () => {
		const {keyframe: currentKeyframeManager, audio: currentAudioManager} =
			managerInstances;

		if (currentKeyframeManager === null || currentAudioManager === null) {
			throw new Error('Media cache managers have not been initialized');
		}

		const keyframeManagerCacheStats = currentKeyframeManager.getCacheStats();
		const audioManagerCacheStats = currentAudioManager.getCacheStats();

		return {
			count: keyframeManagerCacheStats.count + audioManagerCacheStats.count,
			totalSize:
				keyframeManagerCacheStats.totalSize + audioManagerCacheStats.totalSize,
		};
	};

	const keyframeManagerInstance = makeKeyframeManager({
		getTotalCacheStats: getCacheStats,
	});
	const audioManagerInstance = makeAudioManager({
		getTotalCacheStats: getCacheStats,
	});
	managerInstances.keyframe = keyframeManagerInstance;
	managerInstances.audio = audioManagerInstance;
	const queueFrameExtraction = makeSerializedQueue();
	const queueAudioExtraction = makeSerializedQueue();
	let disposed = false;

	return {
		sinkManager,
		keyframeManager: keyframeManagerInstance,
		audioManager: audioManagerInstance,
		getTotalCacheStats: getCacheStats,
		isDisposed: () => disposed,
		queueFrameExtraction,
		queueAudioExtraction,
		dispose: (logLevel: LogLevel) => {
			if (disposed) {
				return;
			}

			disposed = true;
			try {
				keyframeManagerInstance.dispose(logLevel);
			} finally {
				try {
					audioManagerInstance.dispose();
				} finally {
					sinkManager.dispose();
				}
			}
		},
	};
};

export type MediaCache = ReturnType<typeof makeMediaCache>;

export const globalMediaCache = makeMediaCache();
export const {keyframeManager, audioManager, getTotalCacheStats} =
	globalMediaCache;

export const useRenderMediaCache = (logLevel: LogLevel): MediaCache => {
	const renderResourceManager = React.useContext(
		Internals.RenderResourceManagerContext,
	);

	if (renderResourceManager === null) {
		return globalMediaCache;
	}

	return renderResourceManager.getOrCreateResource({
		key: '@remotion/media/cache',
		create: () => {
			const resource = makeMediaCache();

			return {
				resource,
				dispose: () => resource.dispose(logLevel),
			};
		},
	});
};

export {getMaxVideoCacheSize};

export const useMaxMediaCacheSize = (logLevel: LogLevel) => {
	const context = React.useContext(Internals.MaxMediaCacheSizeContext);
	if (context === null) {
		return getMaxVideoCacheSize(logLevel);
	}

	return context;
};