public override Tuple <PlayoutBuilderState, List <PlayoutItem> > Schedule(
PlayoutBuilderState playoutBuilderState,
Dictionary <CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
ProgramScheduleItemFlood scheduleItem,
ProgramScheduleItem nextScheduleItem,
DateTimeOffset hardStop)
{
var playoutItems = new List <PlayoutItem>();
PlayoutBuilderState nextState = playoutBuilderState;
var willFinishInTime = true;
IMediaCollectionEnumerator contentEnumerator =
collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
ProgramScheduleItem peekScheduleItem = nextScheduleItem;
while (contentEnumerator.Current.IsSome && nextState.CurrentTime < hardStop && willFinishInTime)
{
MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
// find when we should start this item, based on the current time
DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
TimeSpan itemDuration = DurationForMediaItem(mediaItem);
List <MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
var playoutItem = new PlayoutItem
{
MediaItemId = mediaItem.Id,
Start = itemStartTime.UtcDateTime,
Finish = itemStartTime.UtcDateTime + itemDuration,
InPoint = TimeSpan.Zero,
OutPoint = itemDuration,
GuideGroup = nextState.NextGuideGroup,
FillerKind = scheduleItem.GuideMode == GuideMode.Filler
? FillerKind.Tail
: FillerKind.None,
WatermarkId = scheduleItem.WatermarkId,
PreferredAudioLanguageCode = scheduleItem.PreferredAudioLanguageCode,
PreferredSubtitleLanguageCode = scheduleItem.PreferredSubtitleLanguageCode,
SubtitleMode = scheduleItem.SubtitleMode
};
DateTimeOffset peekScheduleItemStart =
peekScheduleItem.StartType == StartType.Fixed
? GetStartTimeAfter(nextState with {
InFlood = false
}, peekScheduleItem)
: DateTimeOffset.MaxValue;
DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
collectionEnumerators,
scheduleItem,
itemStartTime,
itemDuration,
itemChapters);
// if the next schedule item is supposed to start during this item,
// don't schedule this item and just move on
willFinishInTime = peekScheduleItemStart < itemStartTime ||
peekScheduleItemStart >= itemEndTimeWithFiller;
if (willFinishInTime)
{
playoutItems.AddRange(
AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
// LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
DateTimeOffset actualEndTime = playoutItems.Max(p => p.FinishOffset);
if (Math.Abs((itemEndTimeWithFiller - actualEndTime).TotalSeconds) > 1)
{
_logger.LogWarning(
"Filler prediction failure: predicted {PredictedDuration} doesn't match actual {ActualDuration}",
itemEndTimeWithFiller,
actualEndTime);
// _logger.LogWarning("Playout items: {@PlayoutItems}", playoutItems);
}
nextState = nextState with
{
CurrentTime = itemEndTimeWithFiller,
InFlood = true,
NextGuideGroup = nextState.IncrementGuideGroup
};
contentEnumerator.MoveNext();
}
}
// _logger.LogDebug(
// "Advancing to next schedule item after playout mode {PlayoutMode}",
// "Flood");
nextState = nextState with
{
InFlood = nextState.CurrentTime >= hardStop,
NextGuideGroup = nextState.DecrementGuideGroup
};
nextState.ScheduleItemsEnumerator.MoveNext();
ProgramScheduleItem peekItem = nextScheduleItem;
DateTimeOffset peekItemStart = GetStartTimeAfter(nextState, peekItem);
if (scheduleItem.TailFiller != null)
{
(nextState, playoutItems) = AddTailFiller(
nextState,
collectionEnumerators,
scheduleItem,
playoutItems,
peekItemStart);
}
if (scheduleItem.FallbackFiller != null)
{
(nextState, playoutItems) = AddFallbackFiller(
nextState,
collectionEnumerators,
scheduleItem,
playoutItems,
peekItemStart);
}
nextState = nextState with {
NextGuideGroup = nextState.IncrementGuideGroup
};
return(Tuple(nextState, playoutItems));
}
}
public override Tuple <PlayoutBuilderState, List <PlayoutItem> > Schedule(
PlayoutBuilderState playoutBuilderState,
Dictionary <CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
ProgramScheduleItemOne scheduleItem,
ProgramScheduleItem nextScheduleItem,
DateTimeOffset hardStop)
{
IMediaCollectionEnumerator contentEnumerator =
collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
foreach (MediaItem mediaItem in contentEnumerator.Current)
{
// find when we should start this item, based on the current time
DateTimeOffset itemStartTime = GetStartTimeAfter(
playoutBuilderState,
scheduleItem);
TimeSpan itemDuration = DurationForMediaItem(mediaItem);
List <MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
var playoutItem = new PlayoutItem
{
MediaItemId = mediaItem.Id,
Start = itemStartTime.UtcDateTime,
Finish = itemStartTime.UtcDateTime + itemDuration,
InPoint = TimeSpan.Zero,
OutPoint = itemDuration,
GuideGroup = playoutBuilderState.NextGuideGroup,
FillerKind = scheduleItem.GuideMode == GuideMode.Filler
? FillerKind.Tail
: FillerKind.None,
WatermarkId = scheduleItem.WatermarkId,
PreferredAudioLanguageCode = scheduleItem.PreferredAudioLanguageCode,
PreferredSubtitleLanguageCode = scheduleItem.PreferredSubtitleLanguageCode,
SubtitleMode = scheduleItem.SubtitleMode
};
DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
collectionEnumerators,
scheduleItem,
itemStartTime,
itemDuration,
itemChapters);
List <PlayoutItem> playoutItems = AddFiller(
playoutBuilderState,
collectionEnumerators,
scheduleItem,
playoutItem,
itemChapters);
PlayoutBuilderState nextState = playoutBuilderState with
{
CurrentTime = itemEndTimeWithFiller
};
nextState.ScheduleItemsEnumerator.MoveNext();
contentEnumerator.MoveNext();
// LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
// only play one item from collection, so always advance to the next item
// _logger.LogDebug(
// "Advancing to next schedule item after playout mode {PlayoutMode}",
// "One");
DateTimeOffset nextItemStart = GetStartTimeAfter(nextState, nextScheduleItem);
if (scheduleItem.TailFiller != null)
{
(nextState, playoutItems) = AddTailFiller(
nextState,
collectionEnumerators,
scheduleItem,
playoutItems,
nextItemStart);
}
if (scheduleItem.FallbackFiller != null)
{
(nextState, playoutItems) = AddFallbackFiller(
nextState,
collectionEnumerators,
scheduleItem,
playoutItems,
nextItemStart);
}
nextState = nextState with {
NextGuideGroup = nextState.IncrementGuideGroup
};
return(Tuple(nextState, playoutItems));
}
return(Tuple(playoutBuilderState, new List <PlayoutItem>()));
}
}
public override Tuple <PlayoutBuilderState, List <PlayoutItem> > Schedule(
PlayoutBuilderState playoutBuilderState,
Dictionary <CollectionKey, IMediaCollectionEnumerator> collectionEnumerators,
ProgramScheduleItemDuration scheduleItem,
ProgramScheduleItem nextScheduleItem,
DateTimeOffset hardStop)
{
var playoutItems = new List <PlayoutItem>();
PlayoutBuilderState nextState = playoutBuilderState;
var willFinishInTime = true;
Option <DateTimeOffset> durationUntil = None;
IMediaCollectionEnumerator contentEnumerator =
collectionEnumerators[CollectionKey.ForScheduleItem(scheduleItem)];
while (contentEnumerator.Current.IsSome && nextState.CurrentTime < hardStop && willFinishInTime)
{
MediaItem mediaItem = contentEnumerator.Current.ValueUnsafe();
// find when we should start this item, based on the current time
DateTimeOffset itemStartTime = GetStartTimeAfter(nextState, scheduleItem);
// remember when we need to finish this duration item
if (nextState.DurationFinish.IsNone)
{
nextState = nextState with
{
DurationFinish = itemStartTime + scheduleItem.PlayoutDuration
};
durationUntil = nextState.DurationFinish;
}
TimeSpan itemDuration = DurationForMediaItem(mediaItem);
List <MediaChapter> itemChapters = ChaptersForMediaItem(mediaItem);
if (itemDuration > scheduleItem.PlayoutDuration)
{
_logger.LogWarning(
"Skipping playout item {Title} with duration {Duration} that is longer than schedule item duration {PlayoutDuration}",
PlayoutBuilder.DisplayTitle(mediaItem),
itemDuration,
scheduleItem.PlayoutDuration);
contentEnumerator.MoveNext();
continue;
}
var playoutItem = new PlayoutItem
{
MediaItemId = mediaItem.Id,
Start = itemStartTime.UtcDateTime,
Finish = itemStartTime.UtcDateTime + itemDuration,
InPoint = TimeSpan.Zero,
OutPoint = itemDuration,
GuideGroup = nextState.NextGuideGroup,
FillerKind = scheduleItem.GuideMode == GuideMode.Filler
? FillerKind.Tail
: FillerKind.None,
CustomTitle = scheduleItem.CustomTitle,
WatermarkId = scheduleItem.WatermarkId,
PreferredAudioLanguageCode = scheduleItem.PreferredAudioLanguageCode,
PreferredSubtitleLanguageCode = scheduleItem.PreferredSubtitleLanguageCode,
SubtitleMode = scheduleItem.SubtitleMode
};
durationUntil.Do(du => playoutItem.GuideFinish = du.UtcDateTime);
DateTimeOffset durationFinish = nextState.DurationFinish.IfNone(SystemTime.MaxValueUtc);
DateTimeOffset itemEndTimeWithFiller = CalculateEndTimeWithFiller(
collectionEnumerators,
scheduleItem,
itemStartTime,
itemDuration,
itemChapters);
willFinishInTime = itemStartTime > durationFinish ||
itemEndTimeWithFiller <= durationFinish;
if (willFinishInTime)
{
// LogScheduledItem(scheduleItem, mediaItem, itemStartTime);
playoutItems.AddRange(
AddFiller(nextState, collectionEnumerators, scheduleItem, playoutItem, itemChapters));
nextState = nextState with
{
CurrentTime = itemEndTimeWithFiller,
// only bump guide group if we don't have a custom title
NextGuideGroup = string.IsNullOrWhiteSpace(scheduleItem.CustomTitle)
? nextState.IncrementGuideGroup
: nextState.NextGuideGroup
};
contentEnumerator.MoveNext();
}
else
{
TimeSpan durationBlock = itemEndTimeWithFiller - itemStartTime;
if (itemEndTimeWithFiller - itemStartTime > scheduleItem.PlayoutDuration)
{
_logger.LogWarning(
"Unable to schedule duration block of {DurationBlock} which is longer than the configured playout duration {PlayoutDuration}",
durationBlock,
scheduleItem.PlayoutDuration);
}
nextState = nextState with
{
DurationFinish = None
};
nextState.ScheduleItemsEnumerator.MoveNext();
}
}
// this is needed when the duration finish exactly matches the hard stop
if (nextState.DurationFinish.IsSome && nextState.CurrentTime == nextState.DurationFinish)
{
nextState = nextState with
{
DurationFinish = None
};
nextState.ScheduleItemsEnumerator.MoveNext();
}
if (playoutItems.Select(pi => pi.GuideGroup).Distinct().Count() != 1)
{
nextState = nextState with {
NextGuideGroup = nextState.DecrementGuideGroup
};
}
foreach (DateTimeOffset nextItemStart in durationUntil)
{
switch (scheduleItem.TailMode)
{
case TailMode.Filler:
if (scheduleItem.TailFiller != null)
{
(nextState, playoutItems) = AddTailFiller(
nextState,
collectionEnumerators,
scheduleItem,
playoutItems,
nextItemStart);
}
if (scheduleItem.FallbackFiller != null)
{
(nextState, playoutItems) = AddFallbackFiller(
nextState,
collectionEnumerators,
scheduleItem,
playoutItems,
nextItemStart);
}
nextState = nextState with {
CurrentTime = nextItemStart
};
break;
case TailMode.Offline:
if (scheduleItem.FallbackFiller != null)
{
(nextState, playoutItems) = AddFallbackFiller(
nextState,
collectionEnumerators,
scheduleItem,
playoutItems,
nextItemStart);
}
nextState = nextState with {
CurrentTime = nextItemStart
};
break;
}
}
// clear guide finish on all but the last item
var all = playoutItems.Filter(pi => pi.FillerKind == FillerKind.None).ToList();
PlayoutItem last = all.OrderBy(pi => pi.FinishOffset).LastOrDefault();
foreach (PlayoutItem item in all.Filter(pi => pi != last))
{
item.GuideFinish = null;
}
nextState = nextState with {
NextGuideGroup = nextState.IncrementGuideGroup
};
return(Tuple(nextState, playoutItems));
}
}