fix: ensure ab sessions get reordered when adlibbing a fixed duration piece

Author: Julusian

packages/job-worker/src/playout/abPlayback/__tests__/abPlaybackResolver.spec.ts

@@ -394,6 +394,47 @@ describe('resolveAbAssignmentsFromRequests', () => {
 		expectGotPlayer(res, 'c', undefined)
 		expectGotPlayer(res, 'd', undefined)
 	})
+	test('Run timed adlib bts', () => {
+		const requests: SessionRequest[] = [
+			// current part
+			{
+				id: 'a',
+				start: 1000,
+				end: 10500,
+				playerId: 2,
+			},
+			// adlib
+			{
+				id: 'b',
+				start: 10000,
+				end: 15000,
+			},
+			// lookaheads (in order of future use)
+			{
+				id: 'c',
+				start: Number.POSITIVE_INFINITY,
+				end: undefined,
+				playerId: 1,
+				lookaheadRank: 1,
+			},
+			{
+				id: 'd',
+				start: Number.POSITIVE_INFINITY,
+				end: undefined,
+				playerId: 2,
+				lookaheadRank: 2,
+			},
+		]
+
+		const res = resolveAbAssignmentsFromRequests(resolverOptions, TWO_SLOTS, requests, 10000)
+		expect(res).toBeTruthy()
+		expect(res.failedOptional).toEqual([])
+		expect(res.failedRequired).toEqual([])
+		expectGotPlayer(res, 'a', 2)
+		expectGotPlayer(res, 'b', 1)
+		expectGotPlayer(res, 'c', 2) // moved so that it alternates
+		expectGotPlayer(res, 'd', 1)
+	})
 
 	test('Autonext run bts', () => {
 		const requests: SessionRequest[] = [

packages/job-worker/src/playout/abPlayback/abPlaybackResolver.ts

@@ -2,13 +2,15 @@ import { ABResolverOptions } from '@sofie-automation/blueprints-integration'
 import { clone } from '@sofie-automation/corelib/dist/lib'
 import * as _ from 'underscore'
 
+export type PlayerId = number | string
+
 export interface SessionRequest {
 	readonly id: string
 	readonly start: number
 	readonly end: number | undefined
 	readonly optional?: boolean
 	readonly lookaheadRank?: number
-	playerId?: number | string
+	playerId?: PlayerId
 }
 
 export interface AssignmentResult {
@@ -21,7 +23,7 @@ export interface AssignmentResult {
 }
 
 interface SlotAvailability {
-	id: number | string
+	id: PlayerId
 	before: (SessionRequest & { end: number }) | null
 	after: SessionRequest | null
 	clashes: SessionRequest[]
@@ -55,7 +57,7 @@ function safeMin<T>(arr: T[], func: (val: T) => number): T | undefined {
  */
 export function resolveAbAssignmentsFromRequests(
 	resolverOptions: ABResolverOptions,
-	playerIds: Array<number | string>,
+	playerIds: PlayerId[],
 	rawRequests: SessionRequest[],
 	now: number // Current time
 ): AssignmentResult {
@@ -80,7 +82,7 @@ export function resolveAbAssignmentsFromRequests(
 		return res
 	}
 
-	const originalLookaheadAssignments: Record<string, number | string> = {}
+	const originalLookaheadAssignments: Record<string, PlayerId> = {}
 	for (const req of rawRequests) {
 		if (req.lookaheadRank !== undefined && req.playerId !== undefined) {
 			originalLookaheadAssignments[req.id] = req.playerId
@@ -104,7 +106,7 @@ export function resolveAbAssignmentsFromRequests(
 	pendingRequests = grouped[undefined as any]
 
 	// build map of slots and what they already have assigned
-	const slots: Map<number | string, SessionRequest[]> = new Map()
+	const slots = new Map<PlayerId, SessionRequest[]>()
 	_.each(playerIds, (id) => slots.set(id, grouped[id] || []))
 
 	const beforeHasGap = (p: SlotAvailability, req: SessionRequest): boolean =>
@@ -311,73 +313,67 @@ export function resolveAbAssignmentsFromRequests(
 		}
 	}
 
+	assignPlayersForLookahead(slots, res, originalLookaheadAssignments, safeNow)
+
+	return res
+}
+
+function assignPlayersForLookahead(
+	slots: Map<PlayerId, SessionRequest[]>,
+	res: AssignmentResult,
+	originalLookaheadAssignments: Record<string, PlayerId>,
+	safeNow: number
+) {
 	// Ensure lookahead gets assigned based on priority not some randomness
 	// Includes slots which have either no sessions, or the last has a known end time
-	const lastSessionPerSlot: Record<number | string, number | undefined> = {} // playerId, end
+	const lastSessionPerSlot = new Map<PlayerId, number>() // playerId, end
 	for (const [playerId, sessions] of slots) {
 		const last = _.last(sessions.filter((s) => s.lookaheadRank === undefined))
 		if (!last) {
-			lastSessionPerSlot[playerId] = Number.NEGATIVE_INFINITY
+			lastSessionPerSlot.set(playerId, Number.NEGATIVE_INFINITY)
 		} else if (last.end !== undefined) {
 			// If there is a defined end, then it can be useful after that point of time
-			lastSessionPerSlot[playerId] = last.end
+			lastSessionPerSlot.set(playerId, last.end)
 		}
 	}
 
 	// Filter down to the lookaheads that we should try to assign
 	const lookaheadsToAssign = _.sortBy(
 		res.requests.filter((r) => r.lookaheadRank !== undefined),
 		(r) => r.lookaheadRank
-	).slice(0, Object.keys(lastSessionPerSlot).length)
-
-	// Persist previous players if possible
-	const remainingLookaheads: SessionRequest[] = []
-	for (const req of lookaheadsToAssign) {
-		delete req.playerId
-
+	).slice(0, lastSessionPerSlot.size)
+
+	const [playersClearNow, playersClearSoon] = _.partition(
+		Array.from(lastSessionPerSlot.entries()),
+		(session) => session[1] < safeNow
+	)
+
+	// Assign the players which are clear right now
+	const playersClearNowIds = new Set(playersClearNow.map((p) => p[0]))
+	// First persist any previous players
+	const lookaheadsToAssignNow = lookaheadsToAssign.slice(0, playersClearNow.length)
+	for (const req of lookaheadsToAssignNow) {
 		const prevPlayer = originalLookaheadAssignments[req.id]
-		if (prevPlayer === undefined) {
-			remainingLookaheads.push(req)
-		} else {
-			// Ensure the assignment is ok
-			const slotEnd = lastSessionPerSlot[prevPlayer]
-			if (slotEnd === undefined || slotEnd >= safeNow) {
-				// It isnt available for this lookahead, or isnt visible yet
-				remainingLookaheads.push(req)
-			} else {
-				// It is ours, so remove the player from the pool
-				req.playerId = prevPlayer
-				delete lastSessionPerSlot[req.playerId]
-			}
-		}
-	}
-
-	// Assign any remaining lookaheads
-	const sortedSlots = _.sortBy(Object.entries<number | undefined>(lastSessionPerSlot), (s) => s[1] ?? 0)
-	for (let i = 0; i < remainingLookaheads.length; i++) {
-		const slot = sortedSlots[i]
-		const req = remainingLookaheads[i]
-
-		if (slot) {
-			// Check if we were originally given a player index rather than a string Id
-			if (playerIds.find((id) => typeof id === 'number' && id === Number(slot[0]))) {
-				req.playerId = Number(slot[0])
-			} else {
-				req.playerId = slot[0]
-			}
+		if (prevPlayer !== undefined && playersClearNowIds.delete(prevPlayer)) {
+			req.playerId = prevPlayer
 		} else {
 			delete req.playerId
 		}
 	}
+	// Then fill in the blanks
+	const playersClearNowRemainingIds = Array.from(playersClearNowIds)
+	for (const req of lookaheadsToAssignNow) {
+		if (req.playerId === undefined) req.playerId = playersClearNowRemainingIds.shift()
+	}
 
-	return res
+	// Assign the players which are clear soon. These aren't visible, so don't need to preserve anything
+	const lookaheadsToAssignSoon = lookaheadsToAssign.slice(playersClearNow.length)
+	for (const req of lookaheadsToAssignSoon) {
+		req.playerId = playersClearSoon.shift()?.[0]
+	}
 }
 
-function getAvailability(
-	id: number | string,
-	thisReq: SessionRequest,
-	orderedRequests: SessionRequest[]
-): SlotAvailability {
+function getAvailability(id: PlayerId, thisReq: SessionRequest, orderedRequests: SessionRequest[]): SlotAvailability {
 	const res: SlotAvailability = {
 		id,
 		before: null,

packages/job-worker/src/playout/abPlayback/index.ts

@@ -1,5 +1,9 @@
 import { ResolvedPieceInstance } from '@sofie-automation/corelib/dist/dataModel/PieceInstance'
-import { ABSessionAssignments, DBRundownPlaylist } from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
+import {
+	ABSessionAssignment,
+	ABSessionAssignments,
+	DBRundownPlaylist,
+} from '@sofie-automation/corelib/dist/dataModel/RundownPlaylist'
 import { OnGenerateTimelineObjExt } from '@sofie-automation/corelib/dist/dataModel/Timeline'
 import { endTrace, sendTrace, startTrace } from '@sofie-automation/corelib/dist/influxdb'
 import { WrappedShowStyleBlueprint } from '../../blueprints/cache'