chore: optimise getSegmentsBetweenMarkers

Author: Mint de Wit

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

@@ -335,6 +335,12 @@ 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(

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

@@ -589,9 +589,11 @@ export class PlayoutModelImpl extends PlayoutModelReadonlyImpl implements Playou
 
 		if (regenerateActivationId) this.playlistImpl.activationId = getRandomId()
 
-		// reset quickloop:
-		this.setQuickLoopMarker('start', null)
-		this.setQuickLoopMarker('end', null)
+		// reset quickloop if applicable:
+		if (this.playlist.quickLoop && !this.playlist.quickLoop.locked) {
+			this.setQuickLoopMarker('start', null)
+			this.setQuickLoopMarker('end', null)
+		}
 
 		this.#playlistHasChanged = true
 	}

packages/job-worker/src/playout/model/services/QuickLoopService.ts

@@ -150,35 +150,55 @@ export class QuickLoopService {
 	}
 
 	getSegmentsBetweenMarkers(startMarker: QuickLoopMarker, endMarker: QuickLoopMarker): SegmentId[] {
-		const orderedParts = this.playoutModel.getAllOrderedParts()
-		const rundownIds = this.playoutModel.getRundownIds()
-
-		const start = this.findQuickLoopMarkerPosition(startMarker, 'start', orderedParts, rundownIds)
-		const end = this.findQuickLoopMarkerPosition(endMarker, 'end', orderedParts, rundownIds)
+		const segments = this.playoutModel.getAllOrderedSegments()
+		const segmentIds: SegmentId[] = []
 
-		if (this.areMarkersFlipped(start, end)) return []
+		let passedStart = false
+		let seenLastRundown = false
 
-		const segmentIds: Set<SegmentId> = new Set()
+		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
+			}
 
-		for (const part of orderedParts) {
-			const currentSegment = this.playoutModel.findSegment(part.segmentId)?.segment
-			const currentRundownIndex = rundownIds.findIndex((id) => id === part.rundownId)
+			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 (!currentSegment) continue // ???
+			if (passedStart) {
+				// passed the start but we have not seen the end yet
+				segmentIds.push(s.segment._id)
+			}
 
 			if (
-				currentRundownIndex >= start.rundownRank &&
-				currentRundownIndex <= end.rundownRank &&
-				currentSegment._rank >= start.segmentRank &&
-				currentSegment._rank <= end.segmentRank &&
-				part._rank >= start.partRank &&
-				part._rank <= start.partRank
+				(endMarker.type === QuickLoopMarkerType.PART && s.getPart(endMarker.id)) ||
+				(endMarker.type === QuickLoopMarkerType.SEGMENT && s.segment._id === endMarker.id)
 			) {
-				segmentIds.add(currentSegment._id)
+				// the endMarker is in this segment or this segment is the end marker
+				break
 			}
 		}
 
-		return Array.from(segmentIds.values())
+		return segmentIds
 	}
 
 	private areMarkersFlipped(startPosition: MarkerPosition, endPosition: MarkerPosition) {

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

@@ -8,6 +8,7 @@ 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(
@@ -20,7 +21,7 @@ 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 oldProps = playoutModel.playlist.quickLoop
+			const oldProps = clone(playoutModel.playlist.quickLoop)
 			const wasQuickLoopRunning = oldProps?.running
 			playoutModel.setQuickLoopMarker(data.type, data.marker)