Skip to content

armgit / Cap

Public Imported from GitHub
0

Open source Loom alternative. Beautiful, shareable screen recordings.

14.2 KB
Raw Blame
export const SLOT_STATE = {
	EMPTY: 0,
	WRITING: 1,
	READY: 2,
	READING: 3,
} as const;

export const PROTOCOL_VERSION = 1;

const CONTROL_BLOCK_SIZE = 64;
const METADATA_ENTRY_SIZE = 12;

const CONTROL_WRITE_INDEX = 0;
const CONTROL_READ_INDEX = 1;
const CONTROL_SHUTDOWN = 2;
const CONTROL_SLOT_COUNT = 3;
const CONTROL_SLOT_SIZE = 4;
const CONTROL_METADATA_OFFSET = 5;
const CONTROL_DATA_OFFSET = 6;
const CONTROL_VERSION = 7;
const _CONTROL_READER_ACTIVE = 8;

const META_FRAME_SIZE = 0;
const META_FRAME_NUMBER = 1;
const META_SLOT_STATE = 2;

export interface SharedFrameBufferConfig {
	slotCount: number;
	slotSize: number;
}

export interface SharedFrameBufferInit {
	buffer: SharedArrayBuffer;
	config: SharedFrameBufferConfig;
}

export function isSharedArrayBufferSupported(): boolean {
	try {
		return (
			typeof SharedArrayBuffer !== "undefined" &&
			typeof Atomics !== "undefined" &&
			(typeof crossOriginIsolated !== "undefined"
				? crossOriginIsolated === true
				: false)
		);
	} catch {
		return false;
	}
}

export function createSharedFrameBuffer(
	config: SharedFrameBufferConfig,
): SharedFrameBufferInit {
	if (
		typeof config.slotCount !== "number" ||
		!Number.isFinite(config.slotCount) ||
		!Number.isInteger(config.slotCount) ||
		config.slotCount <= 0
	) {
		throw new Error(
			`Invalid slotCount: expected a positive integer, got ${config.slotCount}`,
		);
	}
	if (
		typeof config.slotSize !== "number" ||
		!Number.isFinite(config.slotSize) ||
		!Number.isInteger(config.slotSize) ||
		config.slotSize <= 0
	) {
		throw new Error(
			`Invalid slotSize: expected a positive integer, got ${config.slotSize}`,
		);
	}

	const metadataSize = METADATA_ENTRY_SIZE * config.slotCount;
	const totalSize =
		CONTROL_BLOCK_SIZE + metadataSize + config.slotSize * config.slotCount;

	const buffer = new SharedArrayBuffer(totalSize);
	const controlView = new Uint32Array(buffer, 0, 16);

	controlView[CONTROL_WRITE_INDEX] = 0;
	controlView[CONTROL_READ_INDEX] = 0;
	controlView[CONTROL_SHUTDOWN] = 0;
	controlView[CONTROL_SLOT_COUNT] = config.slotCount;
	controlView[CONTROL_SLOT_SIZE] = config.slotSize;
	controlView[CONTROL_METADATA_OFFSET] = CONTROL_BLOCK_SIZE;
	controlView[CONTROL_DATA_OFFSET] = CONTROL_BLOCK_SIZE + metadataSize;
	controlView[CONTROL_VERSION] = PROTOCOL_VERSION;

	const metadataView = new Int32Array(buffer);
	for (let i = 0; i < config.slotCount; i++) {
		const slotMetaIdx = (CONTROL_BLOCK_SIZE + i * METADATA_ENTRY_SIZE) / 4;
		Atomics.store(
			metadataView,
			slotMetaIdx + META_SLOT_STATE,
			SLOT_STATE.EMPTY,
		);
	}

	return { buffer, config };
}

export interface Producer {
	write(frameData: ArrayBuffer): boolean;
	signalShutdown(): void;
}

export function createProducer(init: SharedFrameBufferInit): Producer {
	const { buffer, config } = init;
	const controlView = new Uint32Array(buffer, 0, 8);
	const metadataView = new Int32Array(buffer);
	const metadataOffset = controlView[CONTROL_METADATA_OFFSET];
	const dataOffset = controlView[CONTROL_DATA_OFFSET];
	let frameCounter = 0;

	return {
		write(frameData: ArrayBuffer): boolean {
			if (
				frameData == null ||
				!(frameData instanceof ArrayBuffer) ||
				typeof frameData.byteLength !== "number"
			) {
				throw new TypeError(
					`Invalid frameData: expected ArrayBuffer, got ${frameData == null ? String(frameData) : typeof frameData}`,
				);
			}

			if (frameData.byteLength > config.slotSize) {
				return false;
			}

			const writeIdx = Atomics.load(controlView, CONTROL_WRITE_INDEX);
			const slotMetaIdx = (metadataOffset + writeIdx * METADATA_ENTRY_SIZE) / 4;

			const currentState = Atomics.load(
				metadataView,
				slotMetaIdx + META_SLOT_STATE,
			);
			if (currentState !== SLOT_STATE.EMPTY) {
				return false;
			}

			const exchanged = Atomics.compareExchange(
				metadataView,
				slotMetaIdx + META_SLOT_STATE,
				SLOT_STATE.EMPTY,
				SLOT_STATE.WRITING,
			);
			if (exchanged !== SLOT_STATE.EMPTY) {
				return false;
			}

			if (writeIdx < 0 || writeIdx >= config.slotCount) {
				Atomics.store(
					metadataView,
					slotMetaIdx + META_SLOT_STATE,
					SLOT_STATE.EMPTY,
				);
				return false;
			}

			const slotDataOffset = dataOffset + writeIdx * config.slotSize;

			if (
				slotDataOffset < 0 ||
				slotDataOffset + frameData.byteLength > buffer.byteLength
			) {
				Atomics.store(
					metadataView,
					slotMetaIdx + META_SLOT_STATE,
					SLOT_STATE.EMPTY,
				);
				return false;
			}

			const dest = new Uint8Array(buffer, slotDataOffset, frameData.byteLength);
			dest.set(new Uint8Array(frameData));

			Atomics.store(
				metadataView,
				slotMetaIdx + META_FRAME_SIZE,
				frameData.byteLength,
			);
			const currentFrame = frameCounter;
			frameCounter = (frameCounter + 1) | 0;
			Atomics.store(
				metadataView,
				slotMetaIdx + META_FRAME_NUMBER,
				currentFrame,
			);

			const MAX_CAS_RETRIES = 10;
			let observed = writeIdx;

			for (let casAttempt = 0; casAttempt < MAX_CAS_RETRIES; casAttempt++) {
				const nextIdx = (observed + 1) % config.slotCount;
				const oldValue = Atomics.compareExchange(
					controlView,
					CONTROL_WRITE_INDEX,
					observed,
					nextIdx,
				);

				if (oldValue === observed) {
					Atomics.store(
						metadataView,
						slotMetaIdx + META_SLOT_STATE,
						SLOT_STATE.READY,
					);
					Atomics.notify(metadataView, slotMetaIdx + META_SLOT_STATE, 1);
					return true;
				}

				observed = oldValue;
			}

			Atomics.store(
				metadataView,
				slotMetaIdx + META_SLOT_STATE,
				SLOT_STATE.EMPTY,
			);
			return false;
		},

		signalShutdown(): void {
			Atomics.store(controlView, CONTROL_SHUTDOWN, 1);
			for (let i = 0; i < config.slotCount; i++) {
				const slotMetaIdx = (metadataOffset + i * METADATA_ENTRY_SIZE) / 4;
				Atomics.notify(metadataView, slotMetaIdx + META_SLOT_STATE, 1);
			}
		},
	};
}

export interface BorrowedFrame {
	data: Uint8Array;
	frameSize: number;
	release(): void;
}

export interface Consumer {
	read(timeoutMs?: number): ArrayBuffer | null;
	readInto(target: Uint8Array, timeoutMs?: number): number | null;
	borrow(timeoutMs?: number): BorrowedFrame | null;
	isShutdown(): boolean;
	getSlotSize(): number;
}

function advanceReadIndexCAS(
	controlView: Uint32Array,
	readIdx: number,
	nextIdx: number,
): void {
	const MAX_ADVANCE_RETRIES = 16;
	let expectedIdx = readIdx;

	for (let attempt = 0; attempt < MAX_ADVANCE_RETRIES; attempt++) {
		const exchanged = Atomics.compareExchange(
			controlView,
			CONTROL_READ_INDEX,
			expectedIdx,
			nextIdx,
		);
		if (exchanged === expectedIdx) {
			return;
		}
		const currentIdx = Atomics.load(controlView, CONTROL_READ_INDEX);
		const hasProgressed =
			currentIdx !== readIdx &&
			((nextIdx > readIdx && (currentIdx >= nextIdx || currentIdx < readIdx)) ||
				(nextIdx < readIdx && currentIdx >= nextIdx && currentIdx < readIdx));
		if (hasProgressed) {
			return;
		}
		expectedIdx = exchanged;
	}
}

export function createConsumer(buffer: SharedArrayBuffer): Consumer {
	const controlView = new Uint32Array(buffer, 0, 8);

	const storedVersion = controlView[CONTROL_VERSION];
	if (storedVersion !== PROTOCOL_VERSION) {
		throw new Error(
			`SharedFrameBuffer protocol version mismatch: expected ${PROTOCOL_VERSION}, got ${storedVersion}`,
		);
	}

	const slotCount = controlView[CONTROL_SLOT_COUNT];
	const slotSize = controlView[CONTROL_SLOT_SIZE];
	const metadataOffset = controlView[CONTROL_METADATA_OFFSET];
	const dataOffset = controlView[CONTROL_DATA_OFFSET];
	const metadataView = new Int32Array(buffer);

	return {
		read(timeoutMs: number = 100): ArrayBuffer | null {
			const MAX_CAS_RETRIES = 3;

			for (let attempt = 0; attempt < MAX_CAS_RETRIES; attempt++) {
				const shutdownFlag = Atomics.load(controlView, CONTROL_SHUTDOWN);
				if (shutdownFlag) {
					return null;
				}

				const readIdx = Atomics.load(controlView, CONTROL_READ_INDEX);
				const slotMetaIdx =
					(metadataOffset + readIdx * METADATA_ENTRY_SIZE) / 4;

				let state = Atomics.load(metadataView, slotMetaIdx + META_SLOT_STATE);

				if (state !== SLOT_STATE.READY) {
					const waitResult = Atomics.wait(
						metadataView,
						slotMetaIdx + META_SLOT_STATE,
						state,
						timeoutMs,
					);
					if (waitResult === "timed-out") {
						return null;
					}

					const shutdownCheck = Atomics.load(controlView, CONTROL_SHUTDOWN);
					if (shutdownCheck) {
						return null;
					}

					state = Atomics.load(metadataView, slotMetaIdx + META_SLOT_STATE);
					if (state !== SLOT_STATE.READY) {
						continue;
					}
				}

				const exchangedState = Atomics.compareExchange(
					metadataView,
					slotMetaIdx + META_SLOT_STATE,
					SLOT_STATE.READY,
					SLOT_STATE.READING,
				);
				if (exchangedState !== SLOT_STATE.READY) {
					continue;
				}

				const frameSize = Atomics.load(
					metadataView,
					slotMetaIdx + META_FRAME_SIZE,
				);
				const slotDataOffset = dataOffset + readIdx * slotSize;

				if (
					!Number.isInteger(frameSize) ||
					frameSize < 0 ||
					frameSize > slotSize ||
					slotDataOffset < 0 ||
					slotDataOffset + frameSize > buffer.byteLength
				) {
					Atomics.store(
						metadataView,
						slotMetaIdx + META_SLOT_STATE,
						SLOT_STATE.EMPTY,
					);
					const nextIdx = (readIdx + 1) % slotCount;
					advanceReadIndexCAS(controlView, readIdx, nextIdx);
					return null;
				}

				const frameBuffer = new ArrayBuffer(frameSize);
				new Uint8Array(frameBuffer).set(
					new Uint8Array(buffer, slotDataOffset, frameSize),
				);

				Atomics.store(
					metadataView,
					slotMetaIdx + META_SLOT_STATE,
					SLOT_STATE.EMPTY,
				);

				const nextIdx = (readIdx + 1) % slotCount;
				advanceReadIndexCAS(controlView, readIdx, nextIdx);

				return frameBuffer;
			}

			return null;
		},

		readInto(target: Uint8Array, timeoutMs: number = 100): number | null {
			const MAX_CAS_RETRIES = 3;

			for (let attempt = 0; attempt < MAX_CAS_RETRIES; attempt++) {
				const shutdownFlag = Atomics.load(controlView, CONTROL_SHUTDOWN);
				if (shutdownFlag) {
					return null;
				}

				const readIdx = Atomics.load(controlView, CONTROL_READ_INDEX);
				const slotMetaIdx =
					(metadataOffset + readIdx * METADATA_ENTRY_SIZE) / 4;

				let state = Atomics.load(metadataView, slotMetaIdx + META_SLOT_STATE);

				if (state !== SLOT_STATE.READY) {
					const waitResult = Atomics.wait(
						metadataView,
						slotMetaIdx + META_SLOT_STATE,
						state,
						timeoutMs,
					);
					if (waitResult === "timed-out") {
						return null;
					}

					const shutdownCheck = Atomics.load(controlView, CONTROL_SHUTDOWN);
					if (shutdownCheck) {
						return null;
					}

					state = Atomics.load(metadataView, slotMetaIdx + META_SLOT_STATE);
					if (state !== SLOT_STATE.READY) {
						continue;
					}
				}

				const exchangedState = Atomics.compareExchange(
					metadataView,
					slotMetaIdx + META_SLOT_STATE,
					SLOT_STATE.READY,
					SLOT_STATE.READING,
				);
				if (exchangedState !== SLOT_STATE.READY) {
					continue;
				}

				const frameSize = Atomics.load(
					metadataView,
					slotMetaIdx + META_FRAME_SIZE,
				);
				const slotDataOffset = dataOffset + readIdx * slotSize;

				if (
					!Number.isInteger(frameSize) ||
					frameSize < 0 ||
					frameSize > slotSize ||
					slotDataOffset < 0 ||
					slotDataOffset + frameSize > buffer.byteLength ||
					frameSize > target.byteLength
				) {
					Atomics.store(
						metadataView,
						slotMetaIdx + META_SLOT_STATE,
						SLOT_STATE.EMPTY,
					);
					const nextIdx = (readIdx + 1) % slotCount;
					advanceReadIndexCAS(controlView, readIdx, nextIdx);
					return null;
				}

				target.set(new Uint8Array(buffer, slotDataOffset, frameSize), 0);

				Atomics.store(
					metadataView,
					slotMetaIdx + META_SLOT_STATE,
					SLOT_STATE.EMPTY,
				);

				const nextIdx = (readIdx + 1) % slotCount;
				advanceReadIndexCAS(controlView, readIdx, nextIdx);

				return frameSize;
			}

			return null;
		},

		borrow(timeoutMs: number = 100): BorrowedFrame | null {
			const MAX_CAS_RETRIES = 3;

			for (let attempt = 0; attempt < MAX_CAS_RETRIES; attempt++) {
				const shutdownFlag = Atomics.load(controlView, CONTROL_SHUTDOWN);
				if (shutdownFlag) {
					return null;
				}

				const readIdx = Atomics.load(controlView, CONTROL_READ_INDEX);
				const slotMetaIdx =
					(metadataOffset + readIdx * METADATA_ENTRY_SIZE) / 4;

				let state = Atomics.load(metadataView, slotMetaIdx + META_SLOT_STATE);

				if (state !== SLOT_STATE.READY) {
					const waitResult = Atomics.wait(
						metadataView,
						slotMetaIdx + META_SLOT_STATE,
						state,
						timeoutMs,
					);
					if (waitResult === "timed-out") {
						return null;
					}

					const shutdownCheck = Atomics.load(controlView, CONTROL_SHUTDOWN);
					if (shutdownCheck) {
						return null;
					}

					state = Atomics.load(metadataView, slotMetaIdx + META_SLOT_STATE);
					if (state !== SLOT_STATE.READY) {
						continue;
					}
				}

				const exchangedState = Atomics.compareExchange(
					metadataView,
					slotMetaIdx + META_SLOT_STATE,
					SLOT_STATE.READY,
					SLOT_STATE.READING,
				);
				if (exchangedState !== SLOT_STATE.READY) {
					continue;
				}

				const frameSize = Atomics.load(
					metadataView,
					slotMetaIdx + META_FRAME_SIZE,
				);
				const slotDataOffset = dataOffset + readIdx * slotSize;

				if (
					!Number.isInteger(frameSize) ||
					frameSize < 0 ||
					frameSize > slotSize ||
					slotDataOffset < 0 ||
					slotDataOffset + frameSize > buffer.byteLength
				) {
					Atomics.store(
						metadataView,
						slotMetaIdx + META_SLOT_STATE,
						SLOT_STATE.EMPTY,
					);
					const nextIdx = (readIdx + 1) % slotCount;
					advanceReadIndexCAS(controlView, readIdx, nextIdx);
					return null;
				}

				const data = new Uint8Array(buffer, slotDataOffset, frameSize);

				let released = false;
				const capturedReadIdx = readIdx;
				const capturedSlotMetaIdx = slotMetaIdx;

				const release = () => {
					if (released) return;
					released = true;

					Atomics.store(
						metadataView,
						capturedSlotMetaIdx + META_SLOT_STATE,
						SLOT_STATE.EMPTY,
					);

					const nextIdx = (capturedReadIdx + 1) % slotCount;
					advanceReadIndexCAS(controlView, capturedReadIdx, nextIdx);
				};

				return { data, frameSize, release };
			}

			return null;
		},

		isShutdown(): boolean {
			return Atomics.load(controlView, CONTROL_SHUTDOWN) === 1;
		},

		getSlotSize(): number {
			return slotSize;
		},
	};
}