wip: timeline building

Author: Julusian

packages/job-worker/src/playout/adlibUtils.ts

@@ -323,13 +323,15 @@ export function innerStopPieces(
 
 				const pieceInstanceModel = playoutModel.findPieceInstance(pieceInstance._id)
 				if (pieceInstanceModel) {
-					const newDuration: Required<PieceInstance>['userDuration'] = playoutModel.isMultiGatewayMode
-						? {
-								endRelativeToNow: offsetRelativeToNow,
-						  }
-						: {
-								endRelativeToPart: relativeStopAt,
-						  }
+					const newDuration: Required<PieceInstance>['userDuration'] =
+						playoutModel.isMultiGatewayMode ||
+						pieceInstanceModel.pieceInstance.pieceInstance.piece.enable.isAbsolute
+							? {
+									endRelativeToNow: offsetRelativeToNow,
+							  }
+							: {
+									endRelativeToPart: relativeStopAt,
+							  }
 
 					pieceInstanceModel.pieceInstance.setDuration(newDuration)
 

packages/job-worker/src/playout/infinites.ts

@@ -409,6 +409,8 @@ export async function getBaselineInfinitesForPart(
 	return pieces.map((piece) => {
 		const instance = wrapPieceToInstance(clone<Piece>(piece), playlistActivationId, partInstanceId, false)
 
+		// All these pieces are expected to be outOnRundownChange infinites, as that is how they are ingested
+
 		instance.infinite = {
 			infiniteInstanceId: getRandomId(),
 			infiniteInstanceIndex: 0,

packages/job-worker/src/playout/timeline/rundown.ts

@@ -273,9 +273,25 @@ function generateCurrentInfinitePieceObjects(
 		return []
 	}
 
-	const infiniteGroup = createPartGroup(currentPartInfo.partInstance, {
-		start: `#${timingContext.currentPartGroup.id}.start`, // This gets overriden with a concrete time if the original piece is known to have already started
-	})
+	const { pieceEnable, infiniteGroupEnable, nowInParent } = calculateInfinitePieceEnable(
+		currentPartInfo,
+		timingContext,
+		pieceInstance,
+		currentTime,
+		currentPartInstanceTimings
+	)
+
+	const { pieceInstanceWithUpdatedEndCap, cappedInfiniteGroupEnable } = applyInfinitePieceGroupEndCap(
+		currentPartInfo,
+		timingContext,
+		pieceInstance,
+		infiniteGroupEnable,
+		currentPartInstanceTimings,
+		nextPartInstanceTimings,
+		nextPartInfinites.get(pieceInstance.infinite.infiniteInstanceId)
+	)
+
+	const infiniteGroup = createPartGroup(currentPartInfo.partInstance, cappedInfiniteGroupEnable)
 	infiniteGroup.id = getInfinitePartGroupId(pieceInstance._id) // This doesnt want to belong to a part, so force the ids
 	infiniteGroup.priority = 1
 
@@ -285,6 +301,34 @@ function generateCurrentInfinitePieceObjects(
 		groupClasses.push('continues_infinite')
 	}
 
+	// Still show objects flagged as 'HoldMode.EXCEPT' if this is a infinite continuation as they belong to the previous too
+	const isOriginOfInfinite = pieceInstance.piece.startPartId !== currentPartInfo.partInstance.part._id
+	const isInHold = activePlaylist.holdState === RundownHoldState.ACTIVE
+
+	return [
+		infiniteGroup,
+		...transformPieceGroupAndObjects(
+			activePlaylist._id,
+			infiniteGroup,
+			nowInParent,
+			pieceInstanceWithUpdatedEndCap,
+			pieceEnable,
+			0,
+			groupClasses,
+			isInHold,
+			isOriginOfInfinite
+		),
+	]
+}
+
+function calculateInfinitePieceEnable(
+	currentPartInfo: SelectedPartInstanceTimelineInfo,
+	timingContext: RundownTimelineTimingContext,
+	pieceInstance: ReadonlyDeep<PieceInstanceWithTimings>,
+	// infiniteGroup: TimelineObjGroupPart & OnGenerateTimelineObjExt,
+	currentTime: number,
+	currentPartInstanceTimings: PartCalculatedTimings
+) {
 	const pieceEnable = getPieceEnableInsidePart(
 		pieceInstance,
 		currentPartInstanceTimings,
@@ -293,6 +337,10 @@ function generateCurrentInfinitePieceObjects(
 			timingContext.currentPartGroup.enable.duration !== undefined
 	)
 
+	let infiniteGroupEnable: PartEnable = {
+		start: `#${timingContext.currentPartGroup.id}.start`, // This gets overriden with a concrete time if the original piece is known to have already started
+	}
+
 	let nowInParent = currentPartInfo.nowInPart // Where is 'now' inside of the infiniteGroup?
 	if (pieceInstance.plannedStartedPlayback !== undefined) {
 		// We have a absolute start time, so we should use that.
@@ -311,47 +359,80 @@ function generateCurrentInfinitePieceObjects(
 			pieceEnable.start = 0
 		}
 
-		infiniteGroup.enable = { start: infiniteGroupStart }
+		infiniteGroupEnable = { start: infiniteGroupStart }
 
 		// If an end time has been set by a hotkey, then update the duration to be correct
 		if (pieceInstance.userDuration && pieceInstance.piece.enable.start !== 'now') {
 			if ('endRelativeToPart' in pieceInstance.userDuration) {
-				infiniteGroup.enable.duration =
+				infiniteGroupEnable.duration =
 					pieceInstance.userDuration.endRelativeToPart - pieceInstance.piece.enable.start
 			} else {
-				infiniteGroup.enable.end = 'now'
+				infiniteGroupEnable.end = 'now'
 			}
 		}
+	} else if (pieceInstance.piece.enable.isAbsolute) {
+		// Piece is absolute, so we should use the absolute time. This is a special case for pieces belonging to the rundown directly.
+
+		if (typeof pieceInstance.piece.enable.start === 'number') {
+			nowInParent = currentTime - pieceInstance.piece.enable.start
+		} else {
+			// We should never hit this, but in case start is "now"
+			nowInParent = 0
+		}
+
+		infiniteGroupEnable = { start: pieceInstance.piece.enable.start }
+		pieceEnable.start = 0
+
+		// nocommit prerollDuration?
+
+		// Ingore userDuration, it gets handled later
 	}
 
+	return {
+		pieceEnable,
+		infiniteGroupEnable,
+		nowInParent,
+	}
+}
+
+function applyInfinitePieceGroupEndCap(
+	currentPartInfo: SelectedPartInstanceTimelineInfo,
+	timingContext: RundownTimelineTimingContext,
+	pieceInstance: ReadonlyDeep<PieceInstanceWithTimings>,
+	infiniteGroupEnable: Readonly<PartEnable>,
+	currentPartInstanceTimings: PartCalculatedTimings,
+	nextPartInstanceTimings: PartCalculatedTimings | null,
+	infiniteInNextPart: PieceInstanceWithTimings | undefined
+) {
+	const cappedInfiniteGroupEnable: PartEnable = { ...infiniteGroupEnable }
+
 	// If this infinite piece continues to the next part, and has a duration then we should respect that in case it is really close to the take
 	const hasDurationOrEnd = (enable: TSR.Timeline.TimelineEnable) =>
 		enable.duration !== undefined || enable.end !== undefined
-	const infiniteInNextPart = nextPartInfinites.get(pieceInstance.infinite.infiniteInstanceId)
 	if (
 		infiniteInNextPart &&
-		!hasDurationOrEnd(infiniteGroup.enable) &&
+		!hasDurationOrEnd(cappedInfiniteGroupEnable) &&
 		hasDurationOrEnd(infiniteInNextPart.piece.enable)
 	) {
 		// infiniteGroup.enable.end = infiniteInNextPart.piece.enable.end
-		infiniteGroup.enable.duration = infiniteInNextPart.piece.enable.duration
+		cappedInfiniteGroupEnable.duration = infiniteInNextPart.piece.enable.duration
 	}
 
 	const pieceInstanceWithUpdatedEndCap: PieceInstanceWithTimings = { ...pieceInstance }
 	// Give the infinite group and end cap when the end of the piece is known
 	if (pieceInstance.resolvedEndCap) {
 		// If the cap is a number, it is relative to the part, not the parent group so needs to be handled here
 		if (typeof pieceInstance.resolvedEndCap === 'number') {
-			infiniteGroup.enable.end = `#${timingContext.currentPartGroup.id}.start + ${pieceInstance.resolvedEndCap}`
-			delete infiniteGroup.enable.duration
+			cappedInfiniteGroupEnable.end = `#${timingContext.currentPartGroup.id}.start + ${pieceInstance.resolvedEndCap}`
+			delete cappedInfiniteGroupEnable.duration
 			delete pieceInstanceWithUpdatedEndCap.resolvedEndCap
 		}
 	} else if (
 		// If this piece does not continue in the next part, then set it to end with the part it belongs to
 		!infiniteInNextPart &&
 		currentPartInfo.partInstance.part.autoNext &&
-		infiniteGroup.enable.duration === undefined &&
-		infiniteGroup.enable.end === undefined
+		cappedInfiniteGroupEnable.duration === undefined &&
+		cappedInfiniteGroupEnable.end === undefined
 	) {
 		let endOffset = 0
 
@@ -363,27 +444,10 @@ function generateCurrentInfinitePieceObjects(
 			endOffset -= nextPartInstanceTimings.fromPartKeepalive
 
 		// cap relative to the currentPartGroup
-		infiniteGroup.enable.end = `#${timingContext.currentPartGroup.id}.end + ${endOffset}`
+		cappedInfiniteGroupEnable.end = `#${timingContext.currentPartGroup.id}.end + ${endOffset}`
 	}
 
-	// Still show objects flagged as 'HoldMode.EXCEPT' if this is a infinite continuation as they belong to the previous too
-	const isOriginOfInfinite = pieceInstance.piece.startPartId !== currentPartInfo.partInstance.part._id
-	const isInHold = activePlaylist.holdState === RundownHoldState.ACTIVE
-
-	return [
-		infiniteGroup,
-		...transformPieceGroupAndObjects(
-			activePlaylist._id,
-			infiniteGroup,
-			nowInParent,
-			pieceInstanceWithUpdatedEndCap,
-			pieceEnable,
-			0,
-			groupClasses,
-			isInHold,
-			isOriginOfInfinite
-		),
-	]
+	return { pieceInstanceWithUpdatedEndCap, cappedInfiniteGroupEnable }
 }
 
 function generatePreviousPartInstanceObjects(