Merge remote-tracking branch 'upstream/release52' into upstream/segment-timing

Julusian · Julusian · commit 56f139954467 · 2024-10-24T12:43:13.000+01:00
diff --git a/packages/job-worker/src/playout/model/PlayoutModel.ts b/packages/job-worker/src/playout/model/PlayoutModel.ts
@@ -344,6 +344,14 @@ export interface PlayoutModel extends PlayoutModelReadonly, StudioPlayoutModelBa
 	 */
 	setQuickLoopMarker(type: 'start' | 'end', marker: QuickLoopMarker | null): void
 
+	/**
+	 * Returns any segmentId's that are found between 2 quickloop markers, none will be returned if
+	 * the end is before the start.
+	 * @param start A quickloop marker
+	 * @param end A quickloop marker
+	 */
+	getSegmentsBetweenQuickLoopMarker(start: QuickLoopMarker, end: QuickLoopMarker): SegmentId[]
+
 	calculatePartTimings(
 		fromPartInstance: PlayoutPartInstanceModel | null,
 		toPartInstance: PlayoutPartInstanceModel,
diff --git a/packages/job-worker/src/playout/model/implementation/PlayoutModelImpl.ts b/packages/job-worker/src/playout/model/implementation/PlayoutModelImpl.ts
@@ -594,7 +594,11 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 
 		if (regenerateActivationId) this.playlistImpl.activationId = getRandomId()
 
-		if (this.playlistImpl.quickLoop?.running) this.playlistImpl.quickLoop.running = false
+		// reset quickloop if applicable:
+		if (this.playlist.quickLoop && !this.playlist.quickLoop.locked) {
+			this.setQuickLoopMarker('start', null)
+			this.setQuickLoopMarker('end', null)
+		}
 
 		this.#playlistHasChanged = true
 	}
@@ -793,6 +797,10 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 		this.#playlistHasChanged = true
 	}
 
+	getSegmentsBetweenQuickLoopMarker(start: QuickLoopMarker, end: QuickLoopMarker): SegmentId[] {
+		return this.quickLoopService.getSegmentsBetweenMarkers(start, end)
+	}
+
 	/** Lifecycle */
 
 	/** @deprecated */
diff --git a/packages/job-worker/src/playout/model/services/QuickLoopService.ts b/packages/job-worker/src/playout/model/services/QuickLoopService.ts
@@ -8,7 +8,7 @@ import {
 } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
 import { ReadonlyObjectDeep } from 'type-fest/source/readonly-deep'
 import { DBPart } from '@sofie-automation/corelib/dist/dataModel/Part'
-import { RundownId } from '@sofie-automation/corelib/dist/dataModel/Ids'
+import { RundownId, SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
 import { DBSegment } from '@sofie-automation/corelib/dist/dataModel/Segment'
 import { PlayoutPartInstanceModel } from '../PlayoutPartInstanceModel'
 import { JobContext } from '../../../jobs'
@@ -149,6 +149,58 @@ export class QuickLoopService {
 		return quickLoopProps
 	}
 
+	getSegmentsBetweenMarkers(startMarker: QuickLoopMarker, endMarker: QuickLoopMarker): SegmentId[] {
+		const segments = this.playoutModel.getAllOrderedSegments()
+		const segmentIds: SegmentId[] = []
+
+		let passedStart = false
+		let seenLastRundown = false
+
+		for (const s of segments) {
+			if (
+				(!passedStart &&
+					((startMarker.type === QuickLoopMarkerType.PART && s.getPart(startMarker.id)) ||
+						(startMarker.type === QuickLoopMarkerType.SEGMENT && s.segment._id === startMarker.id) ||
+						(startMarker.type === QuickLoopMarkerType.RUNDOWN &&
+							s.segment.rundownId === startMarker.id))) ||
+				startMarker.type === QuickLoopMarkerType.PLAYLIST
+			) {
+				// the start marker is inside this segment, is this segment, or this is the first segment that is in the loop
+				// segments from here on are included in the loop
+				passedStart = true
+			}
+
+			if (endMarker.type === QuickLoopMarkerType.RUNDOWN) {
+				// last rundown needs to be inclusive so we need to break once the rundownId is not equal to segment's rundownId
+				if (s.segment.rundownId === endMarker.id) {
+					if (!passedStart) {
+						// we hit the end before the start so quit now:
+						break
+					}
+					seenLastRundown = true
+				} else if (seenLastRundown) {
+					// we have passed the last rundown
+					break
+				}
+			}
+
+			if (passedStart) {
+				// passed the start but we have not seen the end yet
+				segmentIds.push(s.segment._id)
+			}
+
+			if (
+				(endMarker.type === QuickLoopMarkerType.PART && s.getPart(endMarker.id)) ||
+				(endMarker.type === QuickLoopMarkerType.SEGMENT && s.segment._id === endMarker.id)
+			) {
+				// the endMarker is in this segment or this segment is the end marker
+				break
+			}
+		}
+
+		return segmentIds
+	}
+
 	private areMarkersFlipped(startPosition: MarkerPosition, endPosition: MarkerPosition) {
 		return compareMarkerPositions(startPosition, endPosition) < 0
 	}
diff --git a/packages/job-worker/src/playout/quickLoopMarkers.ts b/packages/job-worker/src/playout/quickLoopMarkers.ts
@@ -5,6 +5,10 @@ import { runJobWithPlayoutModel } from './lock'
 import { updateTimeline } from './timeline/generate'
 import { selectNextPart } from './selectNextPart'
 import { setNextPart } from './setNext'
+import { resetPartInstancesWithPieceInstances } from './lib'
+import { QuickLoopMarker, QuickLoopMarkerType } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
+import { SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
+import { clone } from 'underscore'
 
 export async function handleSetQuickLoopMarker(context: JobContext, data: SetQuickLoopMarkerProps): Promise<void> {
 	return runJobWithPlayoutModel(
@@ -17,9 +21,74 @@ export async function handleSetQuickLoopMarker(context: JobContext, data: SetQui
 		async (playoutModel) => {
 			const playlist = playoutModel.playlist
 			if (!playlist.activationId) throw new Error(`Playlist has no activationId!`)
-			const wasQuickLoopRunning = playoutModel.playlist.quickLoop?.running
+			const oldProps = clone(playoutModel.playlist.quickLoop)
+			const wasQuickLoopRunning = oldProps?.running
 			playoutModel.setQuickLoopMarker(data.type, data.marker)
 
+			const markerChanged = (
+				markerA: QuickLoopMarker | undefined,
+				markerB: QuickLoopMarker | undefined
+			): boolean => {
+				if (!markerA || !markerB) return false
+
+				if (
+					(markerA.type === QuickLoopMarkerType.RUNDOWN ||
+						markerA.type === QuickLoopMarkerType.SEGMENT ||
+						markerA.type === QuickLoopMarkerType.PART) &&
+					(markerB.type === QuickLoopMarkerType.RUNDOWN ||
+						markerB.type === QuickLoopMarkerType.SEGMENT ||
+						markerB.type === QuickLoopMarkerType.PART)
+				) {
+					return markerA.id !== markerB.id
+				}
+
+				return false
+			}
+
+			if (playlist.currentPartInfo) {
+				// rundown is on air
+				let segmentsToReset: SegmentId[] = []
+
+				if (
+					playlist.quickLoop?.start &&
+					oldProps?.start &&
+					markerChanged(oldProps.start, playlist.quickLoop.start)
+				) {
+					// start marker changed
+					segmentsToReset = playoutModel.getSegmentsBetweenQuickLoopMarker(
+						playlist.quickLoop.start,
+						oldProps.start
+					)
+				} else if (
+					playlist.quickLoop?.end &&
+					oldProps?.end &&
+					markerChanged(oldProps.end, playlist.quickLoop.end)
+				) {
+					// end marker changed
+					segmentsToReset = playoutModel.getSegmentsBetweenQuickLoopMarker(
+						oldProps.end,
+						playlist.quickLoop.end
+					)
+				} else if (playlist.quickLoop?.start && playlist.quickLoop.end && !(oldProps?.start && oldProps.end)) {
+					// a new loop was created
+					segmentsToReset = playoutModel.getSegmentsBetweenQuickLoopMarker(
+						playlist.quickLoop.start,
+						playlist.quickLoop.end
+					)
+				}
+
+				// reset segments that have been added to the loop and are not on-air
+				resetPartInstancesWithPieceInstances(context, playoutModel, {
+					segmentId: {
+						$in: segmentsToReset.filter(
+							(segmentId) =>
+								segmentId !== playoutModel.currentPartInstance?.partInstance.segmentId &&
+								segmentId !== playoutModel.nextPartInstance?.partInstance.segmentId
+						),
+					},
+				})
+			}
+
 			if (wasQuickLoopRunning) {
 				const nextPart = selectNextPart(
 					context,
diff --git a/packages/live-status-gateway/api/schemas/activePlaylist.yaml b/packages/live-status-gateway/api/schemas/activePlaylist.yaml
@@ -29,7 +29,32 @@ $defs:
         $ref: '#/$defs/part'
       publicData:
         description: Optional arbitrary data
-    required: [event, id, name, rundownIds, currentPart, currentSegment, nextPart]
+      timing:
+        description: Timing information about the active playlist
+        type: object
+        properties:
+          timingMode:
+            description: 'Timing mode for the playlist.'
+            type: string
+            enum:
+              - none
+              - forward-time
+              - back-time
+          startedPlayback:
+            description: Unix timestamp of when the playlist started (milliseconds)
+            type: number
+          expectedStart:
+            description: Unix timestamp of when the playlist is expected to start (milliseconds). Required when the timingMode is set to forward-time.
+            type: number
+          expectedDurationMs:
+            description: Duration of the playlist in ms
+            type: number
+          expectedEnd:
+            description: Unix timestamp of when the playlist is expected to end (milliseconds) Required when the timingMode is set to back-time.
+            type: number
+        required: [timingMode]
+        additionalProperties: false
+    required: [event, id, name, rundownIds, currentPart, currentSegment, nextPart, timing]
     additionalProperties: false
     examples:
       - event: activePlaylist
@@ -44,6 +69,10 @@ $defs:
           $ref: '#/$defs/part/examples/0'
         publicData:
           category: 'Evening News'
+        timing:
+          timingMode: 'forward-time'
+          expectedStart: 1728895750727
+          expectedDurationMs: 180000
   partBase:
     type: object
     properties:
diff --git a/packages/live-status-gateway/src/topics/__tests__/activePlaylist.spec.ts b/packages/live-status-gateway/src/topics/__tests__/activePlaylist.spec.ts
@@ -12,6 +12,7 @@ import { DBPart } from '@sofie-automation/corelib/dist/dataModel/Part'
 import { SegmentHandler } from '../../collections/segmentHandler'
 import { DBSegment } from '@sofie-automation/corelib/dist/dataModel/Segment'
 import { CountdownType } from '@sofie-automation/blueprints-integration'
+import { PlaylistTimingType } from '@sofie-automation/blueprints-integration'
 
 function makeEmptyTestPartInstances(): SelectedPartInstances {
 	return {
@@ -49,6 +50,9 @@ describe('ActivePlaylistTopic', () => {
 			currentSegment: null,
 			rundownIds: unprotectStringArray(playlist.rundownIdsInOrder),
 			publicData: undefined,
+			timing: {
+				timingMode: PlaylistTimingType.None,
+			},
 		}
 
 		// eslint-disable-next-line @typescript-eslint/unbound-method
@@ -139,6 +143,9 @@ describe('ActivePlaylistTopic', () => {
 			},
 			rundownIds: unprotectStringArray(playlist.rundownIdsInOrder),
 			publicData: { a: 'b' },
+			timing: {
+				timingMode: PlaylistTimingType.None,
+			},
 		}
 
 		// eslint-disable-next-line @typescript-eslint/unbound-method
diff --git a/packages/live-status-gateway/src/topics/activePlaylistTopic.ts b/packages/live-status-gateway/src/topics/activePlaylistTopic.ts
@@ -17,6 +17,7 @@ import { SelectedPieceInstances, PieceInstancesHandler, PieceInstanceMin } from
 import { PieceStatus, toPieceStatus } from './helpers/pieceStatus'
 import { DBSegment } from '@sofie-automation/corelib/dist/dataModel/Segment'
 import { SegmentHandler } from '../collections/segmentHandler'
+import { PlaylistTimingType } from '@sofie-automation/blueprints-integration'
 
 const THROTTLE_PERIOD_MS = 100
 
@@ -47,6 +48,13 @@ export interface ActivePlaylistStatus {
 	currentSegment: CurrentSegmentStatus | null
 	nextPart: PartStatus | null
 	publicData: unknown
+	timing: {
+		timingMode: PlaylistTimingType
+		startedPlayback?: number
+		expectedStart?: number
+		expectedDurationMs?: number
+		expectedEnd?: number
+	}
 }
 
 export class ActivePlaylistTopic
@@ -146,6 +154,19 @@ export class ActivePlaylistTopic
 						  })
 						: null,
 					publicData: this._activePlaylist.publicData,
+					timing: {
+						timingMode: this._activePlaylist.timing.type,
+						startedPlayback: this._activePlaylist.startedPlayback,
+						expectedDurationMs: this._activePlaylist.timing.expectedDuration,
+						expectedStart:
+							this._activePlaylist.timing.type !== PlaylistTimingType.None
+								? this._activePlaylist.timing.expectedStart
+								: undefined,
+						expectedEnd:
+							this._activePlaylist.timing.type !== PlaylistTimingType.None
+								? this._activePlaylist.timing.expectedEnd
+								: undefined,
+					},
 			  })
 			: literal<ActivePlaylistStatus>({
 					event: 'activePlaylist',
@@ -156,6 +177,9 @@ export class ActivePlaylistTopic
 					currentSegment: null,
 					nextPart: null,
 					publicData: undefined,
+					timing: {
+						timingMode: PlaylistTimingType.None,
+					},
 			  })
 
 		this.sendMessage(subscribers, message)
diff --git a/packages/webui/src/client/lib/rundownTiming.ts b/packages/webui/src/client/lib/rundownTiming.ts
@@ -107,6 +107,8 @@ export class RundownTimingCalculator {
 		let remainingRundownDuration = 0
 		let asPlayedRundownDuration = 0
 		let asDisplayedRundownDuration = 0
+		// the "wait" for a part is defined as its asPlayedDuration or its displayDuration or its expectedDuration
+		const waitPerPart: Record<string, number> = {}
 		let waitAccumulator = 0
 		let currentRemaining = 0
 		let startsAtAccumulator = 0
@@ -436,10 +438,13 @@ export class RundownTimingCalculator {
 						0
 				}
 				if (segmentUsesBudget) {
-					waitAccumulator += Math.min(waitDuration, Math.max(segmentBudgetDurationLeft, 0))
+					const wait = Math.min(waitDuration, Math.max(segmentBudgetDurationLeft, 0))
+					waitAccumulator += wait
 					segmentBudgetDurationLeft -= waitDuration
+					waitPerPart[unprotectString(partId)] = wait + Math.max(0, segmentBudgetDurationLeft)
 				} else {
 					waitAccumulator += waitDuration
+					waitPerPart[unprotectString(partId)] = waitDuration
 				}
 
 				// remaining is the sum of unplayed lines + whatever is left of the current segment
@@ -480,7 +485,9 @@ export class RundownTimingCalculator {
 			})
 
 			// This is where the waitAccumulator-generated data in the linearSegLines is used to calculate the countdowns.
+			// at this point the "waitAccumulator" should be the total sum of all the "waits" in the rundown
 			let localAccum = 0
+			let timeTillEndLoop: undefined | number = undefined
 			for (let i = 0; i < this.linearParts.length; i++) {
 				if (i < nextAIndex) {
 					// this is a line before next line
@@ -517,6 +524,11 @@ export class RundownTimingCalculator {
 					// and add the currentRemaining countdown, since we are currentRemaining + diff between next and
 					// this away from this line.
 					this.linearParts[i][1] = (this.linearParts[i][1] || 0) - localAccum + currentRemaining
+
+					if (!partsInQuickLoop[unprotectString(this.linearParts[i][0])]) {
+						timeTillEndLoop = timeTillEndLoop ?? this.linearParts[i][1] ?? undefined
+					}
+
 					if (nextRundownAnchor === undefined) {
 						nextRundownAnchor = getSegmentRundownAnchorFromPart(
 							this.linearParts[i][0],
@@ -527,13 +539,22 @@ export class RundownTimingCalculator {
 					}
 				}
 			}
-			// contiunation of linearParts calculations for looping playlists
+			// at this point the localAccumulator should be the sum of waits before the next line
+			// continuation of linearParts calculations for looping playlists
 			if (isLoopRunning(playlist)) {
+				// we track the sum of all the "waits" that happen in the loop
+				let waitInLoop = 0
+				// if timeTillEndLoop was undefined then we can assume the end of the loop is the last line in the rundown
+				timeTillEndLoop = timeTillEndLoop ?? waitAccumulator - localAccum + currentRemaining
 				for (let i = 0; i < nextAIndex; i++) {
 					if (!partsInQuickLoop[unprotectString(this.linearParts[i][0])]) continue
-					// offset the parts before the on air line by the countdown for the end of the rundown
-					this.linearParts[i][1] =
-						(this.linearParts[i][1] || 0) + waitAccumulator - localAccum + currentRemaining
+
+					// this countdown is the wait until the loop ends + whatever waits occur before this part but inside the loop
+					this.linearParts[i][1] = timeTillEndLoop + waitInLoop
+
+					// add the wait from this part to the waitInLoop (the lookup here should still work by the definition of a "wait")
+					waitInLoop += waitPerPart[unprotectString(this.linearParts[i][0])] ?? 0
+
 					if (nextRundownAnchor === undefined) {
 						nextRundownAnchor = getSegmentRundownAnchorFromPart(
 							this.linearParts[i][0],
diff --git a/packages/webui/src/client/ui/Prompter/prompter.ts b/packages/webui/src/client/ui/Prompter/prompter.ts
