🎥 Make videos programmatically with React
import {
defaultSelectM3uAssociatedPlaylists,
defaultSelectM3uStreamFn,
} from './containers/m3u/select-stream';
import {mediaParserController} from './controller/media-parser-controller';
import {internalParseMedia} from './internal-parse-media';
import type {MediaParserReaderInterface} from './readers/reader';
import type {SeekingHints} from './seeking-hints';
import {withResolvers} from './with-resolvers';
import {forwardMediaParserControllerToWorker} from './worker/forward-controller-to-worker';
import {serializeError} from './worker/serialize-error';
import type {
AcknowledgePayload,
ParseMediaOnWorkerPayload,
ResponseCallbackPayload,
WorkerRequestPayload,
WorkerResponsePayload,
} from './worker/worker-types';
const post = (message: WorkerResponsePayload) => {
postMessage(message);
};
const controller = mediaParserController();
const executeCallback = (payload: ResponseCallbackPayload) => {
// safari doesn't support crypto.randomUUID()
const nonce = String(Math.random());
const {promise, resolve, reject} = withResolvers<AcknowledgePayload>();
const cb = (msg: MessageEvent) => {
const data = msg.data as WorkerRequestPayload;
if (data.type === 'acknowledge-callback' && data.nonce === nonce) {
const {nonce: _, ...pay} = data;
controller._internals
.checkForAbortAndPause()
.then(() => {
resolve(pay);
})
.catch((err) => {
reject(err);
});
removeEventListener('message', cb);
}
if (data.type === 'signal-error-in-callback') {
reject(new Error('Error in callback function'));
}
};
addEventListener('message', cb);
post({
type: 'response-on-callback-request',
payload,
nonce,
});
return promise;
};
const startParsing = async (
message: ParseMediaOnWorkerPayload,
reader: MediaParserReaderInterface,
) => {
const {payload, src} = message;
const {
fields,
acknowledgeRemotionLicense,
logLevel: userLogLevel,
progressIntervalInMs,
m3uPlaylistContext,
seekingHints,
makeSamplesStartAtZero,
} = payload;
const {
postAudioCodec,
postContainer,
postDimensions,
postFps,
postImages,
postInternalStats,
postIsHdr,
postKeyframes,
postLocation,
postM3uStreams,
postMetadata,
postMimeType,
postName,
postNumberOfAudioChannels,
postRotation,
postSampleRate,
postSlowAudioBitrate,
postSlowNumberOfFrames,
postSlowFps,
postSlowDurationInSeconds,
postSlowVideoBitrate,
postSlowStructure,
postTracks,
postUnrotatedDimensions,
postVideoCodec,
postSize,
postSlowKeyframes,
postDurationInSeconds,
postParseProgress,
postM3uStreamSelection,
postM3uAssociatedPlaylistsSelection,
postOnAudioTrack,
postOnVideoTrack,
} = message;
const logLevel = userLogLevel ?? 'info';
try {
const ret = await internalParseMedia({
src,
reader,
acknowledgeRemotionLicense: Boolean(acknowledgeRemotionLicense),
onError: () => ({action: 'fail'}),
logLevel,
fields: fields ?? null,
apiName: 'parseMediaInWorker()',
controller,
mode: 'query',
onAudioCodec: postAudioCodec
? async (codec) => {
await executeCallback({
callbackType: 'audio-codec',
value: codec,
});
}
: null,
onContainer: postContainer
? async (container) => {
await executeCallback({
callbackType: 'container',
value: container,
});
}
: null,
onDimensions: postDimensions
? async (dimensions) => {
await executeCallback({
callbackType: 'dimensions',
value: dimensions,
});
}
: null,
onFps: postFps
? async (fps) => {
await executeCallback({
callbackType: 'fps',
value: fps,
});
}
: null,
onImages: postImages
? async (images) => {
await executeCallback({
callbackType: 'images',
value: images,
});
}
: null,
onInternalStats: postInternalStats
? async (internalStats) => {
await executeCallback({
callbackType: 'internal-stats',
value: internalStats,
});
}
: null,
onIsHdr: postIsHdr
? async (isHdr) => {
await executeCallback({
callbackType: 'is-hdr',
value: isHdr,
});
}
: null,
onKeyframes: postKeyframes
? async (keyframes) => {
await executeCallback({
callbackType: 'keyframes',
value: keyframes,
});
}
: null,
onLocation: postLocation
? async (location) => {
await executeCallback({
callbackType: 'location',
value: location,
});
}
: null,
onM3uStreams: postM3uStreams
? async (streams) => {
await executeCallback({
callbackType: 'm3u-streams',
value: streams,
});
}
: null,
onMetadata: postMetadata
? async (metadata) => {
await executeCallback({
callbackType: 'metadata',
value: metadata,
});
}
: null,
onMimeType: postMimeType
? async (mimeType) => {
await executeCallback({
callbackType: 'mime-type',
value: mimeType,
});
}
: null,
onName: postName
? async (name) => {
await executeCallback({
callbackType: 'name',
value: name,
});
}
: null,
onNumberOfAudioChannels: postNumberOfAudioChannels
? async (numberOfChannels) => {
await executeCallback({
callbackType: 'number-of-audio-channels',
value: numberOfChannels,
});
}
: null,
onRotation: postRotation
? async (rotation) => {
await executeCallback({
callbackType: 'rotation',
value: rotation,
});
}
: null,
onSampleRate: postSampleRate
? async (sampleRate) => {
await executeCallback({
callbackType: 'sample-rate',
value: sampleRate,
});
}
: null,
onSize: postSize
? async (size) => {
await executeCallback({
callbackType: 'size',
value: size,
});
}
: null,
onSlowAudioBitrate: postSlowAudioBitrate
? async (audioBitrate) => {
await executeCallback({
callbackType: 'slow-audio-bitrate',
value: audioBitrate,
});
}
: null,
onSlowDurationInSeconds: postSlowDurationInSeconds
? async (durationInSeconds) => {
await executeCallback({
callbackType: 'slow-duration-in-seconds',
value: durationInSeconds,
});
}
: null,
onSlowFps: postSlowFps
? async (fps) => {
await executeCallback({
callbackType: 'slow-fps',
value: fps,
});
}
: null,
onSlowKeyframes: postSlowKeyframes
? async (keyframes) => {
await executeCallback({
callbackType: 'slow-keyframes',
value: keyframes,
});
}
: null,
onSlowNumberOfFrames: postSlowNumberOfFrames
? async (numberOfFrames) => {
await executeCallback({
callbackType: 'slow-number-of-frames',
value: numberOfFrames,
});
}
: null,
onSlowVideoBitrate: postSlowVideoBitrate
? async (videoBitrate) => {
await executeCallback({
callbackType: 'slow-video-bitrate',
value: videoBitrate,
});
}
: null,
onSlowStructure: postSlowStructure
? async (structure) => {
await executeCallback({
callbackType: 'slow-structure',
value: structure,
});
}
: null,
onTracks: postTracks
? async (tracks) => {
await executeCallback({
callbackType: 'tracks',
value: tracks,
});
}
: null,
onUnrotatedDimensions: postUnrotatedDimensions
? async (dimensions) => {
await executeCallback({
callbackType: 'unrotated-dimensions',
value: dimensions,
});
}
: null,
onVideoCodec: postVideoCodec
? async (codec) => {
await executeCallback({
callbackType: 'video-codec',
value: codec,
});
}
: null,
onDurationInSeconds: postDurationInSeconds
? async (durationInSeconds) => {
await executeCallback({
callbackType: 'duration-in-seconds',
value: durationInSeconds,
});
}
: null,
onParseProgress: postParseProgress
? async (progress) => {
await executeCallback({
callbackType: 'parse-progress',
value: progress,
});
}
: null,
progressIntervalInMs: progressIntervalInMs ?? null,
selectM3uStream: postM3uStreamSelection
? async (streamIndex) => {
const res = await executeCallback({
callbackType: 'm3u-stream-selection',
value: streamIndex,
});
if (res.payloadType !== 'm3u-stream-selection') {
throw new Error('Invalid response from callback');
}
return res.value;
}
: defaultSelectM3uStreamFn,
m3uPlaylistContext: m3uPlaylistContext ?? null,
selectM3uAssociatedPlaylists: postM3uAssociatedPlaylistsSelection
? async (playlists) => {
const res = await executeCallback({
callbackType: 'm3u-associated-playlists-selection',
value: playlists,
});
if (res.payloadType !== 'm3u-associated-playlists-selection') {
throw new Error('Invalid response from callback');
}
return res.value;
}
: defaultSelectM3uAssociatedPlaylists,
onAudioTrack: postOnAudioTrack
? async (params) => {
const res = await executeCallback({
callbackType: 'on-audio-track',
value: params,
});
if (res.payloadType !== 'on-audio-track-response') {
throw new Error('Invalid response from callback');
}
if (!res.registeredCallback) {
return null;
}
return async (sample) => {
const audioSampleRes = await executeCallback({
callbackType: 'on-audio-sample',
value: sample,
trackId: params.track.trackId,
});
if (audioSampleRes.payloadType !== 'on-sample-response') {
throw new Error('Invalid response from callback');
}
if (!audioSampleRes.registeredTrackDoneCallback) {
return;
}
return async () => {
await executeCallback({
callbackType: 'track-done',
trackId: params.track.trackId,
});
};
};
}
: null,
onVideoTrack: postOnVideoTrack
? async (params) => {
const res = await executeCallback({
callbackType: 'on-video-track',
value: params,
});
if (res.payloadType !== 'on-video-track-response') {
throw new Error('Invalid response from callback');
}
if (!res.registeredCallback) {
return null;
}
return async (sample) => {
const videoSampleRes = await executeCallback({
callbackType: 'on-video-sample',
value: sample,
trackId: params.track.trackId,
});
if (videoSampleRes.payloadType !== 'on-sample-response') {
throw new Error('Invalid response from callback');
}
if (!videoSampleRes.registeredTrackDoneCallback) {
return;
}
return async () => {
await executeCallback({
callbackType: 'track-done',
trackId: params.track.trackId,
});
};
};
}
: null,
onDiscardedData: null,
makeSamplesStartAtZero: makeSamplesStartAtZero ?? true,
seekingHints: seekingHints ?? null,
});
post({
type: 'response-done',
payload: ret,
seekingHints: await controller.getSeekingHints(),
});
} catch (e) {
let seekingHintsRes: SeekingHints | null = null;
try {
seekingHintsRes = await controller.getSeekingHints();
} catch {}
post(
serializeError({
error: e as Error,
logLevel,
seekingHints: seekingHintsRes,
}),
);
}
};
const onMessageForWorker = forwardMediaParserControllerToWorker(controller);
export const messageHandler = (
message: MessageEvent,
readerInterface: MediaParserReaderInterface,
) => {
const data = message.data as WorkerRequestPayload;
if (data.type === 'request-worker') {
startParsing(data, readerInterface);
return;
}
// not handled here
if (data.type === 'acknowledge-callback') {
return;
}
if (data.type === 'signal-error-in-callback') {
return;
}
onMessageForWorker(data);
};