wip: rework

Author: Julusian

packages/job-worker/src/playout/abPlayback/abSessionHelper.ts

@@ -195,12 +195,10 @@ export class AbSessionHelper {
 
 		// Find an normal partInstance
 		const partInstanceId = tlObj.partInstanceId
-		if (partInstanceId) {
-			const partInstanceSession = sessionsToConsider.find((s) => s.partInstanceIds?.includes(partInstanceId))
-			if (partInstanceSession) {
-				partInstanceSession.keep = true
-				return partInstanceSession.id
-			}
+		const partInstanceSession = sessionsToConsider.find((s) => s.partInstanceIds?.includes(partInstanceId))
+		if (partInstanceSession) {
+			partInstanceSession.keep = true
+			return partInstanceSession.id
 		}
 
 		// If it is lookahead, then we run differently

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

@@ -50,6 +50,9 @@ import { applyAbPlaybackForTimeline } from '../abPlayback'
 import { stringifyError } from '@sofie-automation/shared-lib/dist/lib/stringifyError'
 import { PlayoutPartInstanceModel } from '../model/PlayoutPartInstanceModel'
 import { PlayoutChangedType } from '@sofie-automation/shared-lib/dist/peripheralDevice/peripheralDeviceAPI'
+import { PieceInstance } from '@sofie-automation/corelib/dist/dataModel/PieceInstance'
+
+const DEFAULT_ABSOLUTE_PIECE_PREPARE_TIME = 30000
 
 function isModelForStudio(model: StudioPlayoutModelBase): model is StudioPlayoutModel {
 	const tmp = model as StudioPlayoutModel
@@ -257,29 +260,48 @@ export interface SelectedPartInstanceTimelineInfo {
 	partInstance: ReadonlyDeep<DBPartInstance>
 	pieceInstances: PieceInstanceWithTimings[]
 	calculatedTimings: PartCalculatedTimings
+	regenerateTimelineAt: number | undefined
 }
 
 function getPartInstanceTimelineInfo(
+	absolutePiecePrepareTime: number,
 	currentTime: Time,
 	sourceLayers: SourceLayers,
 	partInstance: PlayoutPartInstanceModel | null
 ): SelectedPartInstanceTimelineInfo | undefined {
 	if (!partInstance) return undefined
 
 	const partTimes = createPartCurrentTimes(currentTime, partInstance.partInstance.timings?.plannedStartedPlayback)
-	const pieceInstances = processAndPrunePieceInstanceTimings(
-		sourceLayers,
-		partInstance.pieceInstances.map((p) => p.pieceInstance),
-		partTimes
-	)
+
+	let regenerateTimelineAt: Time | undefined = undefined
+
+	const rawPieceInstances: ReadonlyDeep<PieceInstance>[] = []
+	for (const { pieceInstance } of partInstance.pieceInstances) {
+		if (
+			pieceInstance.piece.enable.isAbsolute &&
+			typeof pieceInstance.piece.enable.start === 'number' &&
+			pieceInstance.piece.enable.start > currentTime + absolutePiecePrepareTime
+		) {
+			// This absolute timed piece is starting too far in the future, ignore it
+			regenerateTimelineAt = Math.min(
+				regenerateTimelineAt ?? Number.POSITIVE_INFINITY,
+				pieceInstance.piece.enable.start - absolutePiecePrepareTime
+			)
+
+			continue
+		}
+
+		rawPieceInstances.push(pieceInstance)
+	}
 
 	const partInstanceWithOverrides = partInstance.getPartInstanceWithQuickLoopOverrides()
 	return {
 		partInstance: partInstanceWithOverrides,
-		pieceInstances,
+		pieceInstances: processAndPrunePieceInstanceTimings(sourceLayers, rawPieceInstances, partTimes),
 		partTimes,
 		// Approximate `calculatedTimings`, for the partInstances which already have it cached
-		calculatedTimings: getPartTimingsOrDefaults(partInstanceWithOverrides, pieceInstances),
+		calculatedTimings: getPartTimingsOrDefaults(partInstanceWithOverrides, rawPieceInstances),
+		regenerateTimelineAt,
 	}
 }
 
@@ -320,10 +342,27 @@ async function getTimelineRundown(
 			}
 
 			const currentTime = getCurrentTime()
+			const absolutePiecePrepareTime =
+				context.studio.settings.rundownGlobalPiecesPrepareTime || DEFAULT_ABSOLUTE_PIECE_PREPARE_TIME
 			const partInstancesInfo: SelectedPartInstancesTimelineInfo = {
-				current: getPartInstanceTimelineInfo(currentTime, showStyle.sourceLayers, currentPartInstance),
-				next: getPartInstanceTimelineInfo(currentTime, showStyle.sourceLayers, nextPartInstance),
-				previous: getPartInstanceTimelineInfo(currentTime, showStyle.sourceLayers, previousPartInstance),
+				current: getPartInstanceTimelineInfo(
+					absolutePiecePrepareTime,
+					currentTime,
+					showStyle.sourceLayers,
+					currentPartInstance
+				),
+				next: getPartInstanceTimelineInfo(
+					absolutePiecePrepareTime,
+					currentTime,
+					showStyle.sourceLayers,
+					nextPartInstance
+				),
+				previous: getPartInstanceTimelineInfo(
+					absolutePiecePrepareTime,
+					currentTime,
+					showStyle.sourceLayers,
+					previousPartInstance
+				),
 			}
 
 			if (partInstancesInfo.next && nextPartInstance) {
@@ -350,14 +389,18 @@ async function getTimelineRundown(
 			timelineObjs = timelineObjs.concat(await pLookaheadObjs)
 
 			let regenerateTimelineToken: string | undefined
-			if (rundownTimelineResult.timingContext?.regenerateTimelineAt) {
+			const regenerateTimelineAt = Math.min(
+				partInstancesInfo.current?.regenerateTimelineAt ?? Number.POSITIVE_INFINITY,
+				partInstancesInfo.next?.regenerateTimelineAt ?? Number.POSITIVE_INFINITY
+			)
+			if (regenerateTimelineAt < Number.POSITIVE_INFINITY) {
 				// The timeline has requested a regeneration at a specific time
 				regenerateTimelineToken = getHash(`regenerate-${playoutModel.playlistId}-${getCurrentTime()}`)
 				timelineObjs.push(
 					literal<TimelineObjRegenerateTrigger & OnGenerateTimelineObjExt>({
 						id: `regenerate_${regenerateTimelineToken}`,
 						enable: {
-							start: rundownTimelineResult.timingContext.regenerateTimelineAt,
+							start: regenerateTimelineAt,
 						},
 						layer: '__timeline_regeneration_trigger__', // Some unique name, as callbacks need to be on a layer
 						priority: 1,

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

@@ -28,8 +28,6 @@ import _ = require('underscore')
 import { getPieceEnableInsidePart, transformPieceGroupAndObjects } from './piece'
 import { logger } from '../../logging'
 
-const DEFAULT_ABSOLUTE_PIECE_PREPARE_TIME = 30000
-
 /**
  * Some additional data used by the timeline generation process
  * Fields are populated as it progresses through generation, and consumed during the finalisation
@@ -39,7 +37,7 @@ export interface RundownTimelineTimingContext {
 	 * How long an absolute timed piece should be on the timeline before it is played
 	 * This is a constant derived from the settings
 	 */
-	readonly absolutePiecePrepareTime: number
+	// readonly absolutePiecePrepareTime: number
 
 	currentPartGroup: TimelineObjGroupPart
 	currentPartDuration: number | undefined
@@ -52,7 +50,7 @@ export interface RundownTimelineTimingContext {
 	/**
 	 * The timeline can request to be regenerated at a specific time, this allows for things to be added to the timeline nearer to when they will be played
 	 */
-	regenerateTimelineAt?: Time
+	// regenerateTimelineAt?: Time
 }
 export interface RundownTimelineResult {
 	timeline: (TimelineObjRundown & OnGenerateTimelineObjExt)[]
@@ -148,8 +146,8 @@ export function buildTimelineObjsForRundown(
 	const currentPartGroup = createPartGroup(partInstancesInfo.current.partInstance, currentPartEnable)
 
 	const timingContext: RundownTimelineTimingContext = {
-		absolutePiecePrepareTime:
-			context.studio.settings.rundownGlobalPiecesPrepareTime || DEFAULT_ABSOLUTE_PIECE_PREPARE_TIME,
+		// absolutePiecePrepareTime:
+		// 	context.studio.settings.rundownGlobalPiecesPrepareTime || DEFAULT_ABSOLUTE_PIECE_PREPARE_TIME,
 		currentPartGroup,
 		currentPartDuration: currentPartEnable.duration,
 	}
@@ -288,21 +286,19 @@ function generateCurrentInfinitePieceObjects(
 		return []
 	}
 
-	const pieceEnable = calculateInfinitePieceEnable(
+	const { infiniteGroupEnable, pieceEnable, nowInParent } = calculateInfinitePieceEnable(
 		currentPartInfo,
 		timingContext,
 		pieceInstance,
 		currentTime,
 		currentPartInstanceTimings
 	)
-	// Not allowed to be generated
-	if (!pieceEnable) return []
 
 	const { pieceInstanceWithUpdatedEndCap, cappedInfiniteGroupEnable } = applyInfinitePieceGroupEndCap(
 		currentPartInfo,
 		timingContext,
 		pieceInstance,
-		pieceEnable.infiniteGroupEnable,
+		infiniteGroupEnable,
 		currentPartInstanceTimings,
 		nextPartInstanceTimings,
 		nextPartInfinites.get(pieceInstance.infinite.infiniteInstanceId)
@@ -327,9 +323,9 @@ function generateCurrentInfinitePieceObjects(
 		...transformPieceGroupAndObjects(
 			activePlaylist._id,
 			infiniteGroup,
-			pieceEnable.nowInParent,
+			nowInParent,
 			pieceInstanceWithUpdatedEndCap,
-			pieceEnable.pieceEnable,
+			pieceEnable,
 			0,
 			groupClasses,
 			isInHold,
@@ -365,15 +361,6 @@ function calculateInfinitePieceEnable(
 		const infiniteGroupStart = pieceInstance.plannedStartedPlayback ?? pieceInstance.piece.enable.start
 
 		if (typeof infiniteGroupStart === 'number') {
-			if (infiniteGroupStart > currentTime + timingContext.absolutePiecePrepareTime) {
-				// This piece is starting too far in the future, omit it from the timeline
-				timingContext.regenerateTimelineAt = Math.min(
-					timingContext.regenerateTimelineAt ?? Number.POSITIVE_INFINITY,
-					infiniteGroupStart - timingContext.absolutePiecePrepareTime
-				)
-				return null
-			}
-
 			nowInParent = currentTime - infiniteGroupStart
 		} else {
 			// We should never hit this, but in case start is "now"