private async Task <bool> ExecuteSeek(TimeSpan time, CancellationToken token)
        {
            dataSynchronizer.Prepare();
            _dataClock.Start();

            var(needDataTcs, asyncHandler) = PrepareStreamStart(ESPlayer.StreamType.Audio, ESPlayer.StreamType.Video);

            using (token.Register(TerminateStreamStart, needDataTcs))
            {
                logger.Info($"Player.SeekAsync({time})");
                var seekTask = player.SeekAsync(time, (s, _) => asyncHandler(s));

                logger.Info($"Player.SeekAsync({time}) Waiting for ready to seek");
                await needDataTcs.Task;

                logger.Info($"Player.SeekAsync({time}) Starting transfer");
                if (false == await StartTransfer(token))
                {
                    _dataClock.Stop();
                    return(false);
                }

                logger.Info($"Player.SeekAsync({time}) Waiting for seek completion");
                await seekTask.WithCancellation(token);

                logger.Info($"Player.SeekAsync({time}) Done");

                StartClockGenerator();
            }

            return(true);
        }
        private async Task ExecutePrepareAsync(CancellationToken token)
        {
            _suspendResumeLogic.SetBuffering(true);
            esStreams[(int)StreamType.Video].RequestFirstDataPacketNotification();

            dataSynchronizer.Prepare();

            logger.Info("Player.PrepareAsync()");

            var asyncOp = player.PrepareAsync(EnableTransfer);

            dataSynchronizer.SetAsyncOperation(asyncOp);
            await asyncOp.WithCancellation(token);

            _suspendResumeLogic.SetBuffering(false);
            logger.Info("Player.PrepareAsync() Completed");
        }
Exemple #3
0
        /// <summary>
        /// Method executes PrepareAsync on ESPlayer. On success, notifies
        /// event PlayerInitialized. At this time player is ALREADY PLAYING
        /// </summary>
        /// <returns>bool
        /// True - AsyncPrepare
        /// </returns>
        private async Task PreparePlayback(CancellationToken token)
        {
            logger.Info("");

            try
            {
                using (await asyncOpSerializer.LockAsync(token))
                {
                    token.ThrowIfCancellationRequested();
                    dataSynchronizer.Prepare();

                    StartClockGenerator();

                    logger.Info("Player.PrepareAsync()");

                    var asyncOp = player.PrepareAsync(async stream => await StartTransfer(stream, token));
                    await asyncOp.WithCancellation(token);

                    logger.Info("Player.PrepareAsync() Done");
                }
            }
            catch (InvalidOperationException ioe)
            {
                logger.Error(ioe);
                playbackErrorSubject.OnNext(ioe.Message);
            }
            catch (Exception e)
                when(e is TaskCanceledException || e is OperationCanceledException)
                {
                    logger.Info("Operation Cancelled");
                    StopTransfer();
                    StopClockGenerator();
                }
            catch (Exception e)
            {
                logger.Error(e);
                playbackErrorSubject.OnNext("Start Failed");
            }
        }