feat: calculate lookahead offsets when setting a take point in the middle of a piece

Author: justandras

packages/job-worker/src/playout/lookahead/findForLayer.ts

@@ -11,54 +11,66 @@ export interface LookaheadResult {
 	future: Array<LookaheadTimelineObject>
 }
 
+export interface PartInstanceAndPieceInstancesInfos {
+	previous?: PartInstanceAndPieceInstances
+	current?: PartInstanceAndPieceInstances
+	next?: PartInstanceAndPieceInstances
+}
+
 export function findLookaheadForLayer(
 	context: JobContext,
-	currentPartInstanceId: PartInstanceId | null,
-	partInstancesInfo: PartInstanceAndPieceInstances[],
-	previousPartInstanceInfo: PartInstanceAndPieceInstances | undefined,
+	partInstancesInfo: PartInstanceAndPieceInstancesInfos,
 	orderedPartInfos: Array<PartAndPieces>,
 	layer: string,
 	lookaheadTargetFutureObjects: number,
-	lookaheadMaxSearchDistance: number
+	lookaheadMaxSearchDistance: number,
+	nextTimeOffset?: number | null
 ): LookaheadResult {
 	const span = context.startSpan(`findLookaheadForlayer.${layer}`)
+	const currentPartId = partInstancesInfo.current?.part._id ?? null
 	const res: LookaheadResult = {
 		timed: [],
 		future: [],
 	}
 
 	// Track the previous info for checking how the timeline will be built
 	let previousPart: ReadonlyDeep<DBPart> | undefined
-	if (previousPartInstanceInfo) {
-		previousPart = previousPartInstanceInfo.part.part
+	if (partInstancesInfo.previous?.part.part) {
+		previousPart = partInstancesInfo.previous.part.part
 	}
 
 	// Generate timed/future objects for the partInstances
-	for (const partInstanceInfo of partInstancesInfo) {
-		if (!partInstanceInfo.onTimeline && lookaheadMaxSearchDistance <= 0) break
+	if (partInstancesInfo.current) {
+		const { objs: currentObjs, partInfo: currentPartInfo } = generatePartInstanceLookaheads(
+			context,
+			partInstancesInfo.current,
+			partInstancesInfo.current.part._id,
+			layer,
+			previousPart
+		)
 
-		const partInfo: PartAndPieces = {
-			part: partInstanceInfo.part.part,
-			usesInTransition: partInstanceInfo.calculatedTimings.inTransitionStart !== null,
-			pieces: sortPieceInstancesByStart(partInstanceInfo.allPieces, partInstanceInfo.nowInPart),
+		if (partInstancesInfo.current.onTimeline) {
+			res.timed.push(...currentObjs)
 		}
+		previousPart = currentPartInfo.part
+	}
 
-		const objs = findLookaheadObjectsForPart(
+	// for Lookaheads in the next part we need to take the nextTimeOffset into account.
+	// TODO: Check if having two pieces after eachother on the same layer is handled correctly
+	if (partInstancesInfo.next) {
+		const { objs: nextObjs, partInfo: nextPartInfo } = generatePartInstanceLookaheads(
 			context,
-			currentPartInstanceId,
+			partInstancesInfo.next,
+			currentPartId,
 			layer,
 			previousPart,
-			partInfo,
-			partInstanceInfo.part._id
+			nextTimeOffset
 		)
 
-		if (partInstanceInfo.onTimeline) {
-			res.timed.push(...objs)
-		} else {
-			res.future.push(...objs)
+		if (partInstancesInfo.next?.onTimeline) {
+			res.future.push(...nextObjs)
 		}
-
-		previousPart = partInfo.part
+		previousPart = nextPartInfo.part
 	}
 
 	if (lookaheadMaxSearchDistance > 1 && lookaheadTargetFutureObjects > 0) {
@@ -69,14 +81,7 @@ export function findLookaheadForLayer(
 			}
 
 			if (partInfo.pieces.length > 0 && isPartPlayable(partInfo.part)) {
-				const objs = findLookaheadObjectsForPart(
-					context,
-					currentPartInstanceId,
-					layer,
-					previousPart,
-					partInfo,
-					null
-				)
+				const objs = findLookaheadObjectsForPart(context, currentPartId, layer, previousPart, partInfo, null)
 				res.future.push(...objs)
 				previousPart = partInfo.part
 			}
@@ -86,3 +91,28 @@ export function findLookaheadForLayer(
 	if (span) span.end()
 	return res
 }
+function generatePartInstanceLookaheads(
+	context: JobContext,
+	partInstanceInfo: PartInstanceAndPieceInstances,
+	currentPartInstanceId: PartInstanceId | null,
+	layer: string,
+	previousPart: ReadonlyDeep<DBPart> | undefined,
+	nextTimeOffset?: number | null
+): { objs: LookaheadTimelineObject[]; partInfo: PartAndPieces } {
+	const partInfo: PartAndPieces = {
+		part: partInstanceInfo.part.part,
+		usesInTransition: partInstanceInfo.calculatedTimings.inTransitionStart !== null,
+		pieces: sortPieceInstancesByStart(partInstanceInfo.allPieces, partInstanceInfo.nowInPart),
+	}
+
+	const objs = findLookaheadObjectsForPart(
+		context,
+		currentPartInstanceId,
+		layer,
+		previousPart,
+		partInfo,
+		partInstanceInfo.part._id,
+		nextTimeOffset ?? undefined
+	)
+	return { objs, partInfo }
+}

packages/job-worker/src/playout/lookahead/findObjects.ts

@@ -92,7 +92,8 @@ export function findLookaheadObjectsForPart(
 	layer: string,
 	previousPart: ReadonlyDeep<DBPart> | undefined,
 	partInfo: PartAndPieces,
-	partInstanceId: PartInstanceId | null
+	partInstanceId: PartInstanceId | null,
+	nextTimeOffset?: number
 ): Array<LookaheadTimelineObject> {
 	// Sanity check, if no part to search, then abort
 	if (!partInfo || partInfo.pieces.length === 0) {
@@ -105,6 +106,31 @@ export function findLookaheadObjectsForPart(
 
 		const obj = getObjectMapForPiece(rawPiece).get(layer)
 		if (obj) {
+			// TODO: forcing these types feels wrong, do we even need to take the object's enable into account?
+			const objEnable: typeof rawPiece.piece.enable = Array.isArray(obj.enable)
+				? (obj.enable[0] as typeof rawPiece.piece.enable)
+				: (obj.enable as typeof rawPiece.piece.enable)
+			let lookaheadOffset: number | undefined
+
+			if (nextTimeOffset) {
+				const pieceStart = rawPiece.piece.enable.start === 'now' ? 0 : rawPiece.piece.enable.start
+				const objStart = objEnable.start === 'now' ? 0 : objEnable.start
+
+				const offset = nextTimeOffset - pieceStart - objStart
+
+				lookaheadOffset = offset > 0 ? offset : undefined
+			} else {
+				lookaheadOffset = undefined
+			}
+			// TODO: remove console log before PR
+			// console.log(
+			// 	`--------------------------LOOK HERE---------------------------2\n${JSON.stringify(
+			// 		{ ...obj, lookaheadOffset },
+			// 		null,
+			// 		2
+			// 	)}`
+			// )
+			console.log('lookaheadOffset: ' + nextTimeOffset)
 			allObjs.push(
 				literal<LookaheadTimelineObject>({
 					metaData: undefined,
@@ -113,6 +139,7 @@ export function findLookaheadObjectsForPart(
 					pieceInstanceId: getBestPieceInstanceId(rawPiece),
 					infinitePieceInstanceId: rawPiece.infinite?.infiniteInstanceId,
 					partInstanceId: partInstanceId ?? protectString(unprotectString(partInfo.part._id)),
+					lookaheadOffset,
 				})
 			)
 		}

packages/job-worker/src/playout/lookahead/index.ts

@@ -1,5 +1,5 @@
 import { getOrderedPartsAfterPlayhead, PartAndPieces, PartInstanceAndPieceInstances } from './util'
-import { findLookaheadForLayer, LookaheadResult } from './findForLayer'
+import { findLookaheadForLayer, LookaheadResult, PartInstanceAndPieceInstancesInfos } from './findForLayer'
 import { PlayoutModel } from '../model/PlayoutModel'
 import { sortPieceInstancesByStart } from '../pieces'
 import { MappingExt } from '@sofie-automation/corelib/dist/dataModel/Studio'
@@ -90,8 +90,21 @@ export async function getLookeaheadObjects(
 		},
 	})
 
-	const partInstancesInfo: PartInstanceAndPieceInstances[] = _.compact([
-		partInstancesInfo0.current
+	// Track the previous info for checking how the timeline will be built
+	let previousPartInfo: PartInstanceAndPieceInstances | undefined
+	if (partInstancesInfo0.previous) {
+		previousPartInfo = removeInfiniteContinuations({
+			part: partInstancesInfo0.previous.partInstance,
+			onTimeline: true,
+			nowInPart: partInstancesInfo0.previous.nowInPart,
+			allPieces: getPrunedEndedPieceInstances(partInstancesInfo0.previous),
+			calculatedTimings: partInstancesInfo0.previous.calculatedTimings,
+		})
+	}
+
+	const partInstancesInfo: PartInstanceAndPieceInstancesInfos = {
+		previous: previousPartInfo,
+		current: partInstancesInfo0.current
 			? removeInfiniteContinuations({
 					part: partInstancesInfo0.current.partInstance,
 					onTimeline: true,
@@ -100,7 +113,7 @@ export async function getLookeaheadObjects(
 					calculatedTimings: partInstancesInfo0.current.calculatedTimings,
 			  })
 			: undefined,
-		partInstancesInfo0.next
+		next: partInstancesInfo0.next
 			? removeInfiniteContinuations({
 					part: partInstancesInfo0.next.partInstance,
 					onTimeline: !!partInstancesInfo0.current?.partInstance?.part?.autoNext, //TODO -QL
@@ -109,18 +122,6 @@ export async function getLookeaheadObjects(
 					calculatedTimings: partInstancesInfo0.next.calculatedTimings,
 			  })
 			: undefined,
-	])
-
-	// Track the previous info for checking how the timeline will be built
-	let previousPartInfo: PartInstanceAndPieceInstances | undefined
-	if (partInstancesInfo0.previous) {
-		previousPartInfo = removeInfiniteContinuations({
-			part: partInstancesInfo0.previous.partInstance,
-			onTimeline: true,
-			nowInPart: partInstancesInfo0.previous.nowInPart,
-			allPieces: getPrunedEndedPieceInstances(partInstancesInfo0.previous),
-			calculatedTimings: partInstancesInfo0.previous.calculatedTimings,
-		})
 	}
 
 	// TODO: Do we need to use processAndPrunePieceInstanceTimings on these pieces? In theory yes, but that gets messy and expensive.
@@ -164,13 +165,12 @@ export async function getLookeaheadObjects(
 
 			const lookaheadObjs = findLookaheadForLayer(
 				context,
-				playoutModel.playlist.currentPartInfo?.partInstanceId ?? null,
 				partInstancesInfo,
-				previousPartInfo,
 				orderedPartInfos,
 				layerId,
 				lookaheadTargetObjects,
-				lookaheadMaxSearchDistance
+				lookaheadMaxSearchDistance,
+				playoutModel.playlist.nextTimeOffset
 			)
 
 			timelineObjs.push(...processResult(lookaheadObjs, mapping.lookahead))