Merge pull request Sofie-Automation#1283 from bbc/upstream/fix-quickloop-timers

Author: jstarpl

packages/job-worker/src/playout/model/PlayoutModel.ts

@@ -343,6 +343,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,

packages/job-worker/src/playout/model/implementation/PlayoutModelImpl.ts

@@ -593,7 +593,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
 	}
@@ -792,6 +796,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 */

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
 	}

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,

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
@@ -438,10 +440,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
@@ -482,7 +487,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
@@ -519,6 +526,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],
@@ -529,13 +541,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],