@omnimedia/omnitool 1.1.0-9 → 1.1.0-90

package/s/timeline/renderers/parts/handy.ts

@@ -0,0 +1,418 @@
+
+import {ms, Ms} from '../../../units/ms.js'
+import {Id, TimelineFile} from '../../parts/basics.js'
+import {Keyframes, TransformAnimation} from '../../types.js'
+import { SampleContext } from './samplers/visual/parts/types.js'
+import {I6, Mat6, mul6, transformToMat6} from '../../utils/matrix.js'
+import {ContainerItem, Item, Kind, PlayableItem} from '../../parts/item.js'
+import {resolveScalarAnimation, resolveTransformAnimation} from '../../utils/anim.js'
+
+function isPlayableItem(item: Item.Any): item is PlayableItem {
+	return 'duration' in item
+}
+
+type WalkAtCallbacks = {
+	sequence: (x: Item.Sequence, localTime: Ms, ancestors: AncestorAt[]) => void
+	stack: (x: Item.Stack, localTime: Ms, ancestors: AncestorAt[]) => void
+	video: (x: Item.Video, localTime: Ms, ancestors: AncestorAt[]) => void
+	text: (x: Item.Text, localTime: Ms, ancestors: AncestorAt[]) => void
+	audio: (x: Item.Audio, localTime: Ms, ancestors: AncestorAt[]) => void
+}
+
+type WalkCallbacks = {
+	sequence?: (x: Item.Sequence, matrix: Mat6, ancestors: AncestorAt[]) => void
+	stack?: (x: Item.Stack, matrix: Mat6, ancestors: AncestorAt[]) => void
+	video?: (x: Item.Video, matrix: Mat6, ancestors: AncestorAt[]) => void
+	text?: (x: Item.Text, matrix: Mat6, ancestors: AncestorAt[]) => void
+	audio?: (x: Item.Audio) => void
+}
+
+interface Props {
+	timeline: TimelineFile
+	timecode: Ms
+}
+
+export interface AncestorAt {
+	item: ContainerItem
+	localTime: Ms
+}
+
+interface At {
+	item: Item.Any
+	localTime: Ms
+	ancestors: AncestorAt[]
+}
+
+export function itemsAt(p: Props): At[] {
+	const results: At[] = []
+	const itemMap = new Map(p.timeline.items.map(item => [item.id, item]))
+
+	walkAt(p.timeline.rootId, itemMap, p.timecode, {
+		sequence: () => { },
+		stack: () => { },
+		video: (item, localTime, ancestors) => results.push({ item, localTime, ancestors }),
+		text: (item, localTime, ancestors) => results.push({ item, localTime, ancestors }),
+		audio: (item, localTime, ancestors) => results.push({ item, localTime, ancestors })
+	})
+
+	return results
+}
+
+interface FromProps {
+	timeline: TimelineFile
+	from: Ms
+}
+
+export function itemsFrom(p: FromProps): At[] {
+	const results: At[] = []
+	const itemMap = new Map(p.timeline.items.map(item => [item.id, item]))
+
+	walkFrom(p.timeline.rootId, itemMap, p.from, {
+		sequence: () => { },
+		stack: () => { },
+		video: (item, localTime, ancestors) => results.push({ item, localTime, ancestors }),
+		text: (item, localTime, ancestors) => results.push({ item, localTime, ancestors }),
+		audio: (item, localTime, ancestors) => results.push({ item, localTime, ancestors })
+	})
+
+	return results
+}
+
+export function computeWorldMatrix(
+	items: Map<Id, Item.Any>,
+	ancestors: AncestorAt[],
+	item: Item.Any,
+	localTime: Ms,
+): Mat6 {
+	let world = I6
+
+	for (const ancestor of ancestors) {
+		world = applySpatialIfAny(items, ancestor.item, world, ancestor.localTime)
+	}
+
+	return applySpatialIfAny(items, item, world, localTime)
+}
+
+function applySpatialIfAny(
+	items: Map<Id, Item.Any>,
+	item: Item.Any,
+	parentMatrix: Mat6,
+	time: Ms,
+) {
+	let matrix = parentMatrix
+	if ("spatialId" in item && item.spatialId) {
+		const spatial = items.get(item.spatialId) as Item.Spatial | undefined
+		if (spatial?.enabled) {
+			const local = transformToMat6(spatial.transform)
+			matrix = mul6(local, matrix)
+		}
+	}
+
+	if ("animationIds" in item && item.animationIds) {
+		for (const id of item.animationIds) {
+			const animation = items.get(id) as Item.Animation | undefined
+			const anim = animation?.anims.transform
+			if (animation?.enabled && anim && transformActiveAt(anim, time)) {
+				const local = transformToMat6(resolveTransformAnimation(time, anim))
+				matrix = mul6(local, matrix)
+			}
+		}
+	}
+
+	return matrix
+}
+
+export function walk(
+	id: Id,
+	items: Map<Id, Item.Any>,
+	parentMatrix: Mat6,
+	localTime: Ms,
+	callbacks: WalkCallbacks,
+	ancestors: AncestorAt[] = []
+) {
+	const item = items.get(id)
+	if (!item) return
+
+	const currentMatrix = applySpatialIfAny(items, item, parentMatrix, localTime)
+
+	switch (item.kind) {
+		case Kind.Stack:
+			callbacks.stack?.(item, currentMatrix, ancestors)
+			for (const childId of item.childrenIds) {
+				walk(childId, items, currentMatrix, localTime, callbacks, [...ancestors, {item, localTime}])
+			}
+			break
+
+		case Kind.Sequence: {
+			callbacks.sequence?.(item, currentMatrix, ancestors)
+
+			for (const childId of item.childrenIds) {
+				const child = items.get(childId)
+
+				if (!child)
+					continue
+				if (!isPlayableItem(child)) {
+					continue
+				}
+
+				walk(
+					childId,
+					items,
+					currentMatrix,
+					localTime,
+					callbacks,
+					[...ancestors, {item, localTime}]
+				)
+			}
+
+			break
+		}
+
+		case Kind.Video:
+			callbacks.video?.(item, currentMatrix, ancestors)
+			break
+
+		case Kind.Text:
+			callbacks.text?.(item, currentMatrix, ancestors)
+			break
+
+		case Kind.Audio:
+			callbacks.audio?.(item)
+			break
+	}
+}
+
+
+function walkAt(
+	id: Id,
+	items: Map<Id, Item.Any>,
+	time: Ms,
+	callbacks: WalkAtCallbacks,
+	ancestors: AncestorAt[] = []
+) {
+	const item = items.get(id)
+	if (!item) return
+
+	switch (item.kind) {
+		case Kind.Stack:
+			callbacks.stack(item, time, ancestors)
+			for (const childId of item.childrenIds) {
+				walkAt(childId, items, time, callbacks, [...ancestors, {item, localTime: time}])
+			}
+			break
+
+		case Kind.Sequence: {
+			callbacks.sequence(item, time, ancestors)
+
+			let offset = ms(0)
+
+			for (const childId of item.childrenIds) {
+				const child = items.get(childId)
+
+				if (!child)
+					continue
+				if (!isPlayableItem(child)) {
+					continue
+				}
+
+				if (time >= offset && time < offset + child.duration) {
+					const localTime = ms(time - offset)
+					walkAt(
+						childId,
+						items,
+						localTime,
+						callbacks,
+						[...ancestors, {item, localTime: time}]
+					)
+					break
+				}
+
+				offset = ms(offset + child.duration)
+			}
+
+			break
+		}
+
+		case Kind.Video:
+			callbacks.video(item, time, ancestors)
+			break
+
+		case Kind.Text:
+			callbacks.text(item, time, ancestors)
+			break
+
+		case Kind.Audio:
+			callbacks.audio(item, time, ancestors)
+			break
+	}
+}
+
+function walkFrom(
+	id: Id,
+	items: Map<Id, Item.Any>,
+	from: Ms,
+	callbacks: WalkAtCallbacks,
+	ancestors: AncestorAt[] = []
+) {
+	const item = items.get(id)
+	if (!item) return
+
+	switch (item.kind) {
+		case Kind.Stack:
+			callbacks.stack(item, from, ancestors)
+			for (const childId of item.childrenIds) {
+				walkFrom(childId, items, from, callbacks, [...ancestors, {item, localTime: from}])
+			}
+			break
+
+		case Kind.Sequence: {
+			callbacks.sequence(item, from, ancestors)
+
+			let offset = ms(0)
+
+			for (const childId of item.childrenIds) {
+				const child = items.get(childId)
+
+				if (!child)
+					continue
+				if (!isPlayableItem(child)) {
+					continue
+				}
+
+				const end = ms(offset + child.duration)
+				if (from >= end) {
+					offset = end
+					continue
+				}
+
+				const localTime = ms(Math.max(0, from - offset))
+				walkFrom(
+					childId,
+					items,
+					localTime,
+					callbacks,
+					[...ancestors, {item, localTime: from}]
+				)
+
+				offset = end
+			}
+
+			break
+		}
+
+		case Kind.Video:
+			callbacks.video(item, from, ancestors)
+			break
+
+		case Kind.Text:
+			callbacks.text(item, from, ancestors)
+			break
+
+		case Kind.Audio:
+			callbacks.audio(item, from, ancestors)
+			break
+	}
+}
+
+export function computeItemDuration(
+	id: number,
+	timeline: TimelineFile
+): Ms {
+	const item = timeline.items.find(item => item.id === id)
+
+	if (!item) return ms(0)
+
+	switch (item.kind) {
+		case Kind.Sequence: {
+			const children = item.childrenIds
+				.map(childId => timeline.items.find(x => x.id === childId))
+				.filter(Boolean) as Item.Any[]
+
+			let total = ms(0)
+
+			for (let i = 0; i < children.length; i++) {
+				const child = children[i]
+
+				if (child.kind === Kind.Transition) {
+					const prev = children[i - 1]
+					const next = children[i + 1]
+
+					if (prev && next && prev.kind !== Kind.Transition && next.kind !== Kind.Transition) {
+						const prevDur = computeItemDuration(prev.id, timeline)
+						const nextDur = computeItemDuration(next.id, timeline)
+						const overlap = Math.max(0, Math.min(child.duration, prevDur, nextDur))
+
+						total = ms(total - overlap)
+					}
+					continue
+				}
+
+				total = ms(total + computeItemDuration(child.id, timeline))
+			}
+
+			return total
+		}
+
+		case Kind.Stack: {
+			let longest = ms(0)
+
+			for (const childId of item.childrenIds) {
+				const duration = computeItemDuration(childId, timeline)
+				if (duration > longest) {
+					longest = duration
+				}
+			}
+
+			return longest
+		}
+
+		default: {
+			if (!isPlayableItem(item))
+				return ms(0)
+
+			return item.duration
+		}
+	}
+}
+
+export function computeOpacity(
+	ctx: SampleContext,
+	item: Item.Any,
+	time: Ms,
+) {
+	if (!("animationIds" in item) || item.animationIds === undefined)
+		return 1
+
+	let opacity = 1
+	for (const id of item.animationIds) {
+		const animation = ctx.items.get(id) as Item.Animation | undefined
+		const anim = animation?.anims.opacity
+		if (animation?.enabled && anim && keyframesActiveAt(anim.track, time))
+			opacity = resolveScalarAnimation(time, anim)
+	}
+	return opacity
+}
+
+function keyframesActiveAt(keys: Keyframes, time: Ms) {
+	if (keys.length === 0)
+		return false
+
+	let start = keys[0][0]
+	let end = keys[0][0]
+	for (const [keyTime] of keys) {
+		start = Math.min(start, keyTime)
+		end = Math.max(end, keyTime)
+	}
+
+	return time >= start && time <= end
+}
+
+function transformActiveAt(anim: TransformAnimation, time: Ms) {
+	return (
+		keyframesActiveAt(anim.track.position.x, time) ||
+		keyframesActiveAt(anim.track.position.y, time) ||
+		keyframesActiveAt(anim.track.scale.x, time) ||
+		keyframesActiveAt(anim.track.scale.y, time) ||
+		keyframesActiveAt(anim.track.rotation, time)
+	)
+}

package/s/timeline/renderers/parts/samplers/audio/parts/find.ts

@@ -0,0 +1,19 @@
+
+import {ActiveStream} from "./types.js"
+
+export function findEarliestStream(streams: ActiveStream[]) {
+	let earliest = {
+		index: 0,
+		stream: streams[0],
+		time: streams[0].timelineTime()
+	}
+
+	for (const [index, stream] of streams.entries()) {
+		const time = stream.timelineTime()
+		if (time < earliest.time) {
+			earliest = {time, stream, index}
+		}
+	}
+
+	return earliest
+}

package/s/timeline/renderers/parts/samplers/audio/parts/init.ts

@@ -0,0 +1,60 @@
+
+import {AudioSinkPool} from "./sink.js"
+import {ActiveStream} from "./types.js"
+import {itemsFrom} from "../../../handy.js"
+import {Ms} from "../../../../../../units/ms.js"
+import {Kind} from "../../../../../parts/item.js"
+import {seconds} from "../../../../../../units/seconds.js"
+
+export async function initStreams(
+	pool: AudioSinkPool,
+	items: ReturnType<typeof itemsFrom>,
+	from: Ms
+): Promise<ActiveStream[]> {
+	const streams = await Promise.all(
+		items.map(async ({item, localTime}) => {
+			if (item.kind !== Kind.Audio)
+				return
+
+			const sink = await pool.getSink(item.mediaHash)
+			if (!sink)
+				return
+
+			const mediaTime = item.start + localTime
+			const offset = seconds((from - mediaTime) / 1000)
+			const iter = sink.samples(mediaTime / 1000)
+
+			const first = await iter.next()
+			if (first.done)
+				return
+
+			let currentSample = first.value
+			let nextPromise = iter.next()
+
+			return {
+				offset,
+				gain: item.gain ?? 1,
+				get currentSample() {return currentSample},
+				timelineTime: () => seconds(offset + currentSample.timestamp),
+				output: () => ({
+					sample: currentSample,
+					timestamp: offset + currentSample.timestamp,
+					gain: item.gain ?? 1
+				}),
+				advance: async () => {
+					const result = await nextPromise
+					if (result.done)
+						return false
+
+					currentSample = result.value
+					nextPromise = iter.next()
+
+					return true
+				}
+			}
+		})
+	)
+
+	return streams.filter((stream): stream is ActiveStream => !!stream)
+}
+

package/s/timeline/renderers/parts/samplers/audio/parts/sink.ts

@@ -0,0 +1,38 @@
+
+import {ALL_FORMATS, Input, AudioSampleSink} from "mediabunny"
+
+import {DecoderSource} from "../../../../../../driver/fns/schematic.js"
+import {loadDecoderSource} from "../../../../../../driver/utils/load-decoder-source.js"
+
+type SinkState = {
+	input: Input
+	sink: AudioSampleSink | null
+}
+
+export class AudioSinkPool {
+	readonly #sinks = new Map<string, SinkState>()
+
+	constructor(
+		private resolveMedia: (hash: string) => DecoderSource
+	) {}
+
+	async getSink(hash: string) {
+		const existing = this.#sinks.get(hash)
+
+		if (existing)
+			return existing.sink
+
+		const input = new Input({
+			formats: ALL_FORMATS,
+			source: await loadDecoderSource(this.resolveMedia(hash)),
+		})
+
+		const audioTrack = await input.getPrimaryAudioTrack()
+		const canDecodeAudio = !!audioTrack && await audioTrack.canDecode()
+		const sink = canDecodeAudio && audioTrack ? new AudioSampleSink(audioTrack) : null
+
+		this.#sinks.set(hash, {input, sink})
+
+		return sink
+	}
+}

package/s/timeline/renderers/parts/samplers/audio/parts/types.ts

@@ -0,0 +1,16 @@
+
+import {AudioSample} from "mediabunny"
+import {Seconds} from "../../../../../../units/seconds.js"
+
+export type ActiveStream = {
+	offset: Seconds
+	gain: number
+	currentSample: AudioSample
+	timelineTime: () => Seconds
+	output: () => {
+		sample: AudioSample
+		timestamp: number
+		gain: number
+	}
+	advance: () => Promise<boolean>
+}

package/s/timeline/renderers/parts/samplers/audio/sampler.ts

@@ -0,0 +1,35 @@
+
+import {AudioSample} from "mediabunny"
+
+import {itemsFrom} from "../../handy.js"
+import {initStreams} from "./parts/init.js"
+import {AudioSinkPool} from "./parts/sink.js"
+import {Ms} from "../../../../../units/ms.js"
+import {findEarliestStream} from "./parts/find.js"
+import {TimelineFile} from "../../../../parts/basics.js"
+import {DecoderSource} from "../../../../../driver/fns/schematic.js"
+
+export function createAudioSampler(resolveMedia: (hash: string) => DecoderSource) {
+	const sinkPool = new AudioSinkPool(resolveMedia)
+
+	return {
+		async *sampleAudio(timeline: TimelineFile, from: Ms) {
+			const items = itemsFrom({timeline, from})
+			const streams = await initStreams(sinkPool, items, from)
+
+			while (streams.length > 0) {
+				const {stream, index} = findEarliestStream(streams)
+
+				yield stream.output()
+
+				const advancing = await stream.advance()
+
+				if (!advancing) {
+					streams.splice(index, 1)
+				}
+			}
+
+		}
+	}
+}
+

package/s/timeline/renderers/parts/samplers/visual/parts/defaults.ts

@@ -0,0 +1,16 @@
+
+import {VideoSink} from "./sink.js"
+import {Ms} from "../../../../../../units/ms.js"
+import {Item} from "../../../../../parts/item.js"
+
+export type VideoSampler = (item: Item.Video, time: Ms) => Promise<VideoFrame | undefined>
+
+export function createDefaultVideoSampler(sink: VideoSink): VideoSampler {
+	return async (item, time) => {
+		const s = await sink.getSink(item.mediaHash)
+		const sample = await s?.getSample(time / 1000)
+		const frame = sample?.toVideoFrame()
+		sample?.close()
+		return frame ?? undefined
+	}
+}

package/s/timeline/renderers/parts/samplers/visual/parts/sample.ts

@@ -0,0 +1,69 @@
+
+import {SampleContext} from "./types.js"
+import {sampleSequence} from "./sequence.js"
+import {Ms} from "../../../../../../units/ms.js"
+import {Item, Kind} from "../../../../../parts/item.js"
+import {FilterSpec, Layer} from "../../../../../../driver/fns/schematic.js"
+import {AncestorAt, computeOpacity, computeWorldMatrix} from "../../../handy.js"
+
+export async function sampleVisual(
+	ctx: SampleContext,
+	item: Item.Any,
+	time: Ms,
+	ancestors: AncestorAt[]
+): Promise<Layer[]> {
+	const matrix = computeWorldMatrix(ctx.items, ancestors, item, time)
+	const alpha = computeOpacity(ctx, item, time)
+	const crop = "spatialId" in item && item.spatialId
+		? (ctx.items.get(item.spatialId) as Item.Spatial | undefined)?.crop
+		: undefined
+	const filters = "filterIds" in item && item.filterIds
+		? item.filterIds
+			.map(id => ctx.items.get(id) as Item.Filter | undefined)
+			.filter((filter): filter is Item.Filter => !!filter?.enabled)
+			.map(filter => ({type: filter.type, params: filter.params}) as FilterSpec)
+		: undefined
+
+	switch (item.kind) {
+		case Kind.Stack: {
+			const nextAnc = [...ancestors, {item, localTime: time}]
+
+			const layers = await Promise.all(
+				item.childrenIds
+					.map(id => ctx.items.get(id))
+					.filter((child): child is Item.Any => !!child)
+					.map(child => sampleVisual(ctx, child, time, nextAnc))
+			)
+
+			return layers.flat()
+		}
+
+		case Kind.Sequence:
+			return sampleSequence(ctx, item, time, ancestors)
+
+		case Kind.Video: {
+			if (time < 0 || time >= item.duration) return []
+
+			const frame = await ctx.videoSampler(item, time)
+			return frame ? [{kind: "image", frame, matrix, alpha, crop, filters, id: item.id}] : []
+		}
+
+		case Kind.Text: {
+			if (time < 0 || time >= item.duration) return []
+
+			const style = item.styleId
+				? (ctx.items.get(item.styleId) as Item.TextStyle)?.style
+				: undefined
+
+			return [{id: item.id, kind: "text", content: item.content, style, matrix, alpha, crop, filters}]
+		}
+
+		case Kind.Gap: {
+			return [{id: item.id, kind: "gap"}]
+		}
+
+		default:
+			return []
+	}
+}
+