Merge pull request #1721 from bbc/feat/SOFIE-449-duration-based-timing-mode

Feat/sofie 449 duration based timing mode

Author: jesperstarkar

packages/blueprints-integration/src/documents/playlistTiming.ts

@@ -4,6 +4,7 @@ export enum PlaylistTimingType {
 	None = 'none',
 	ForwardTime = 'forward-time',
 	BackTime = 'back-time',
+	Duration = 'duration',
 }
 
 export interface PlaylistTimingBase {
@@ -49,4 +50,29 @@ export interface PlaylistTimingBackTime extends PlaylistTimingBase {
 	expectedEnd: Time
 }
 
-export type RundownPlaylistTiming = PlaylistTimingNone | PlaylistTimingForwardTime | PlaylistTimingBackTime
+/**
+ * This mode is intended for shows with a "floating start",
+ * meaning they will start based on when the show before them on the channel ends.
+ * In this mode, we will preserve the Duration and automatically calculate the expectedEnd
+ * based on the _actual_ start of the show (playlist.startedPlayback).
+ *
+ * The optional expectedStart property allows setting a start property of the show that will not affect
+ * timing calculations, only purpose is to drive UI and inform the users about the preliminary plan as
+ * planned in the editorial planning tool.
+ */
+export interface PlaylistTimingDuration extends PlaylistTimingBase {
+	type: PlaylistTimingType.Duration
+	/** A stipulated start time, to drive UIs pre-show, but not affecting calculations during the show.
+	 */
+	expectedStart?: Time
+	/** Planned duration of the rundown playlist
+	 *  When the show starts, an expectedEnd gets automatically calculated with this as an offset from that starting point
+	 */
+	expectedDuration: number
+}
+
+export type RundownPlaylistTiming =
+	| PlaylistTimingNone
+	| PlaylistTimingForwardTime
+	| PlaylistTimingBackTime
+	| PlaylistTimingDuration

packages/corelib/src/playout/rundownTiming.ts

@@ -13,6 +13,7 @@
 
 import {
 	PlaylistTimingBackTime,
+	PlaylistTimingDuration,
 	PlaylistTimingForwardTime,
 	PlaylistTimingNone,
 	PlaylistTimingType,
@@ -34,6 +35,10 @@ export namespace PlaylistTiming {
 		return timing.type === PlaylistTimingType.BackTime
 	}
 
+	export function isPlaylistDurationTimed(timing: RundownPlaylistTiming): timing is PlaylistTimingDuration {
+		return timing.type === PlaylistTimingType.Duration
+	}
+
 	export function getExpectedStart(timing: RundownPlaylistTiming): number | undefined {
 		if (PlaylistTiming.isPlaylistTimingForwardTime(timing)) {
 			return timing.expectedStart
@@ -42,19 +47,29 @@ export namespace PlaylistTiming {
 				timing.expectedStart ||
 				(timing.expectedDuration ? timing.expectedEnd - timing.expectedDuration : undefined)
 			)
+		} else if (PlaylistTiming.isPlaylistDurationTimed(timing)) {
+			return timing.expectedStart
 		} else {
 			return undefined
 		}
 	}
 
-	export function getExpectedEnd(timing: RundownPlaylistTiming): number | undefined {
+	export function getExpectedEnd(timing: RundownPlaylistTiming, startedPlayback?: number): number | undefined {
 		if (PlaylistTiming.isPlaylistTimingBackTime(timing)) {
 			return timing.expectedEnd
 		} else if (PlaylistTiming.isPlaylistTimingForwardTime(timing)) {
 			return (
 				timing.expectedEnd ||
 				(timing.expectedDuration ? timing.expectedStart + timing.expectedDuration : undefined)
 			)
+		} else if (PlaylistTiming.isPlaylistDurationTimed(timing)) {
+			if (!startedPlayback) {
+				// before the show, estimate the end from start + dur
+				return timing.expectedStart ? timing.expectedStart + timing.expectedDuration : undefined
+			} else {
+				// after starting the show, project the end from startedPlayback + dur
+				return startedPlayback + timing.expectedDuration
+			}
 		} else {
 			return undefined
 		}
@@ -70,6 +85,20 @@ export namespace PlaylistTiming {
 		}
 	}
 
+	export function getEstimatedEnd(
+		timing: RundownPlaylistTiming,
+		now: number,
+		remainingPlaylistDuration?: number,
+		startedPlayback?: number
+	): number | undefined {
+		if (remainingPlaylistDuration !== undefined) {
+			const frontAnchor = startedPlayback ? now : Math.max(now, PlaylistTiming.getExpectedStart(timing) ?? now)
+
+			return frontAnchor + remainingPlaylistDuration
+		}
+		return undefined
+	}
+
 	export function sortTimings(
 		a: ReadonlyDeep<{ timing: RundownPlaylistTiming }>,
 		b: ReadonlyDeep<{ timing: RundownPlaylistTiming }>

packages/live-status-gateway-api/api/components/timing/activePlaylistTiming/activePlaylistTimingMode.yaml

@@ -5,3 +5,4 @@ enum:
   - none
   - forward-time
   - back-time
+  - duration

packages/live-status-gateway-api/src/generated/asyncapi.yaml

@@ -660,6 +660,7 @@ channels:
                         - none
                         - forward-time
                         - back-time
+                        - duration
                     startedPlayback:
                       description: Unix timestamp of when the playlist started (milliseconds)
                       type: number

packages/live-status-gateway-api/src/generated/schema.ts

@@ -423,6 +423,7 @@ enum ActivePlaylistTimingMode {
 	NONE = 'none',
 	FORWARD_MINUS_TIME = 'forward-time',
 	BACK_MINUS_TIME = 'back-time',
+	DURATION = 'duration',
 }
 
 /**

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

@@ -181,7 +181,8 @@ export class ActivePlaylistTopic extends WebSocketTopicBase implements WebSocket
 								? this._activePlaylist.timing.expectedStart
 								: undefined,
 						expectedEnd:
-							this._activePlaylist.timing.type !== PlaylistTimingType.None
+							this._activePlaylist.timing.type !== PlaylistTimingType.None &&
+							this._activePlaylist.timing.type !== PlaylistTimingType.Duration
 								? this._activePlaylist.timing.expectedEnd
 								: undefined,
 					},
@@ -402,6 +403,8 @@ function translatePlaylistTimingType(type: PlaylistTimingType): ActivePlaylistTi
 			return ActivePlaylistTimingMode.BACK_MINUS_TIME
 		case PlaylistTimingType.ForwardTime:
 			return ActivePlaylistTimingMode.FORWARD_MINUS_TIME
+		case PlaylistTimingType.Duration:
+			return ActivePlaylistTimingMode.DURATION
 		default:
 			assertNever(type)
 			// Cast and return the value anyway, so that the application works

packages/webui/src/client/lib/rundownTiming.ts

@@ -855,6 +855,13 @@ export function getPlaylistTimingDiff(
 		frontAnchor = Math.max(currentTime, playlist.startedPlayback ?? Math.max(timing.expectedStart, currentTime))
 	} else if (PlaylistTiming.isPlaylistTimingBackTime(timing)) {
 		backAnchor = timingContext.nextRundownAnchor ?? timing.expectedEnd
+	} else if (PlaylistTiming.isPlaylistDurationTimed(timing)) {
+		const backAnchorTimeWithoutBreaks =
+			timingContext.nextRundownAnchor ??
+			PlaylistTiming.getExpectedEnd(timing, playlist.startedPlayback) ??
+			currentTime + timing.expectedDuration
+		backAnchor = timingContext.nextRundownAnchor ?? backAnchorTimeWithoutBreaks
+		frontAnchor = Math.max(currentTime, playlist.startedPlayback || PlaylistTiming.getExpectedStart(timing) || 0)
 	}
 
 	let diff = PlaylistTiming.isPlaylistTimingNone(timing)
@@ -880,9 +887,11 @@ export function getPlaylistTimingDiff(
 			diff =
 				(timingContext.asPlayedPlaylistDuration || 0) -
 				(timing.expectedDuration ?? timingContext.totalPlaylistDuration ?? 0)
-		} else if (PlaylistTiming.isPlaylistTimingBackTime(timing)) {
-			// we want to see how late we've ended compared to the expectedEnd
-			diff = startedPlayback + (timingContext.asPlayedPlaylistDuration || 0) - timing.expectedEnd
+		} else if (PlaylistTiming.isPlaylistDurationTimed(timing)) {
+			//  we want to know how heavy/light we were compared to the original plan
+			diff =
+				(timingContext.asPlayedPlaylistDuration || 0) -
+				(timing.expectedDuration ?? timingContext.totalPlaylistDuration ?? 0)
 		}
 	}
 

packages/webui/src/client/ui/RundownView/RundownHeader/RundownHeaderExpectedEnd.tsx

@@ -14,24 +14,23 @@ export function RundownHeaderExpectedEnd({
 	const { t } = useTranslation()
 	const timingDurations = useTiming()
 
-	const expectedStart = PlaylistTiming.getExpectedStart(playlist.timing)
-	const expectedEnd = PlaylistTiming.getExpectedEnd(playlist.timing)
 	const now = timingDurations.currentTime ?? Date.now()
+	const expectedEnd = PlaylistTiming.getExpectedEnd(playlist.timing, playlist.startedPlayback)
+	const estEnd = PlaylistTiming.getEstimatedEnd(
+		playlist.timing,
+		now,
+		timingDurations.remainingPlaylistDuration,
+		playlist.startedPlayback
+	)
 
-	// Use remainingPlaylistDuration which includes current part's remaining time
-	const estEnd =
-		timingDurations.remainingPlaylistDuration !== undefined
-			? Math.max(now, expectedStart ?? now) + timingDurations.remainingPlaylistDuration
-			: null
-
-	if (expectedEnd === undefined && estEnd === null) return null
+	if (expectedEnd === undefined && estEnd === undefined) return null
 
 	return (
 		<div className="rundown-header__show-timers-endtimes">
 			{!simplified && expectedEnd !== undefined ? (
 				<Countdown label={t('Plan. End')} time={expectedEnd} className="rundown-header__show-timers-countdown" />
 			) : null}
-			{estEnd !== null ? (
+			{estEnd !== undefined ? (
 				<Countdown label={t('Est. End')} time={estEnd} className="rundown-header__show-timers-countdown" />
 			) : null}
 		</div>