Esempio n. 1
0
 public Task<Command> ForError(
     string ffmpegPath,
     Channel channel,
     Option<TimeSpan> duration,
     string errorMessage,
     bool hlsRealtime,
     long ptsOffset) =>
     _ffmpegProcessService.ForError(ffmpegPath, channel, duration, errorMessage, hlsRealtime, ptsOffset);
Esempio n. 2
0
        protected override async Task <Either <BaseError, Process> > GetProcess(
            GetPlayoutItemProcessByChannelNumber _,
            Channel channel,
            string ffmpegPath)
        {
            DateTimeOffset now = DateTimeOffset.Now;
            Either <BaseError, PlayoutItemWithPath> maybePlayoutItem = await _playoutRepository
                                                                       .GetPlayoutItem(channel.Id, now)
                                                                       .Map(o => o.ToEither <BaseError>(new UnableToLocatePlayoutItem()))
                                                                       .BindT(ValidatePlayoutItemPath);

            return(await maybePlayoutItem.Match(
                       async playoutItemWithPath =>
            {
                MediaVersion version = playoutItemWithPath.PlayoutItem.MediaItem switch
                {
                    Movie m => m.MediaVersions.Head(),
                    Episode e => e.MediaVersions.Head(),
                    _ => throw new ArgumentOutOfRangeException(nameof(playoutItemWithPath))
                };

                bool saveReports = await _configElementRepository.GetValue <bool>(ConfigElementKey.FFmpegSaveReports)
                                   .Map(result => result.IfNone(false));

                return Right <BaseError, Process>(
                    _ffmpegProcessService.ForPlayoutItem(
                        ffmpegPath,
                        saveReports,
                        channel,
                        version,
                        playoutItemWithPath.Path,
                        playoutItemWithPath.PlayoutItem.StartOffset,
                        now));
            },
                       async error =>
            {
                var offlineTranscodeMessage =
                    $"offline image is unavailable because transcoding is disabled in ffmpeg profile '{channel.FFmpegProfile.Name}'";

                Option <TimeSpan> maybeDuration = await Optional(channel.FFmpegProfile.Transcode)
                                                  .Filter(transcode => transcode)
                                                  .Match(
                    _ => _playoutRepository.GetNextItemStart(channel.Id, now)
                    .MapT(nextStart => nextStart - now),
                    () => Option <TimeSpan> .None.AsTask());

                switch (error)
                {
                case UnableToLocatePlayoutItem:
                    if (channel.FFmpegProfile.Transcode)
                    {
                        return _ffmpegProcessService.ForError(
                            ffmpegPath,
                            channel,
                            maybeDuration,
                            "Channel is Offline");
                    }
                    else
                    {
                        var message =
                            $"Unable to locate playout item for channel {channel.Number}; {offlineTranscodeMessage}";

                        return BaseError.New(message);
                    }

                case PlayoutItemDoesNotExistOnDisk:
                    if (channel.FFmpegProfile.Transcode)
                    {
                        return _ffmpegProcessService.ForError(ffmpegPath, channel, maybeDuration, error.Value);
                    }
                    else
                    {
                        var message =
                            $"Playout item does not exist on disk for channel {channel.Number}; {offlineTranscodeMessage}";

                        return BaseError.New(message);
                    }

                default:
                    if (channel.FFmpegProfile.Transcode)
                    {
                        return _ffmpegProcessService.ForError(
                            ffmpegPath,
                            channel,
                            maybeDuration,
                            "Channel is Offline");
                    }
                    else
                    {
                        var message =
                            $"Unexpected error locating playout item for channel {channel.Number}; {offlineTranscodeMessage}";

                        return BaseError.New(message);
                    }
                }
            }));
        }