Merge remote-tracking branch 'upstream/release52' into bbc-release52

Author: Julusian

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

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

@@ -594,9 +594,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

@@ -9,6 +9,7 @@ import { resetPartInstancesWithPieceInstances } from './lib'
 import { QuickLoopMarker, QuickLoopMarkerType } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
 import { SegmentId } from '@sofie-automation/corelib/dist/dataModel/Ids'
 import { PlayoutModel } from './model/PlayoutModel'
+import { clone } from 'underscore'
 
 export async function handleSetQuickLoopMarker(context: JobContext, data: SetQuickLoopMarkerProps): Promise<void> {
 	return runJobWithPlayoutModel(
@@ -21,10 +22,8 @@ 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)
 
 			const markerChanged = (

packages/live-status-gateway/api/schemas/activePlaylist.yaml

@@ -63,7 +63,7 @@ $defs:
           expectedStart:
             description: Unix timestamp of when the playlist is expected to start (milliseconds). Required when the timingMode is set to forward-time.
             type: number
-          expectedDuration:
+          expectedDurationMs:
             description: Duration of the playlist in ms
             type: number
           expectedEnd:
@@ -89,7 +89,7 @@ $defs:
         timing:
           timingMode: 'forward-time'
           expectedStart: 1728895750727
-          duration: 180000
+          expectedDurationMs: 180000
   partBase:
     type: object
     properties:

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 {
@@ -50,6 +51,9 @@ describe('ActivePlaylistTopic', () => {
 			rundownIds: unprotectStringArray(playlist.rundownIdsInOrder),
 			publicData: undefined,
 			quickLoop: undefined,
+			timing: {
+				timingMode: PlaylistTimingType.None,
+			},
 		}
 
 		// eslint-disable-next-line @typescript-eslint/unbound-method
@@ -141,6 +145,9 @@ describe('ActivePlaylistTopic', () => {
 			rundownIds: unprotectStringArray(playlist.rundownIdsInOrder),
 			publicData: { a: 'b' },
 			quickLoop: undefined,
+			timing: {
+				timingMode: PlaylistTimingType.None,
+			},
 		}
 
 		// eslint-disable-next-line @typescript-eslint/unbound-method

packages/live-status-gateway/src/topics/activePlaylistTopic.ts

@@ -73,7 +73,7 @@ export interface ActivePlaylistStatus {
 		timingMode: PlaylistTimingType
 		startedPlayback?: number
 		expectedStart?: number
-		expectedDuration?: number
+		expectedDurationMs?: number
 		expectedEnd?: number
 	}
 }
@@ -181,7 +181,7 @@ export class ActivePlaylistTopic
 					timing: {
 						timingMode: this._activePlaylist.timing.type,
 						startedPlayback: this._activePlaylist.startedPlayback,
-						expectedDuration: this._activePlaylist.timing.expectedDuration,
+						expectedDurationMs: this._activePlaylist.timing.expectedDuration,
 						expectedStart:
 							this._activePlaylist.timing.type !== PlaylistTimingType.None
 								? this._activePlaylist.timing.expectedStart