Пример #1
0
        public void OnClearStream()
        {
            Logger.Info($"{streamType}");

            currentCdmInstance = null;
            config             = null;
        }
Пример #2
0
        public async Task OnDRMFound(DrmInitData data)
        {
            using (await packetStreamLock.LockAsync())
            {
                Logger.Info($"{streamType}");

                if (!forceDrmChange && currentCdmInstance != null)
                {
                    return;
                }

                IDrmSession newSession = await drmManager.GetDrmSession(data);

                // Do not reset wait for DRM event. If there is no valid session
                // do not want to append new data
                //
                if (newSession == null)
                {
                    return;
                }

                Logger.Info($"{streamType}: New DRM session found");
                forceDrmChange = false;

                // Set new session as current & let data submitters run wild.
                // There is no need to store sessions. They live in player queue
                currentCdmInstance = newSession.CdmInstance;
            }
        }
Пример #3
0
        /// <summary>
        /// Pushes encrypted data packet to ESPlayer.
        /// Decryption is performed prior to packet push.
        /// </summary>
        /// <param name="dataPacket">Packet</param>
        /// <param name="token">CancellationToken</param>
        /// <exception cref="PacketSubmitException">
        /// Exception thrown on submit error
        /// </exception>
        /// <exception cref="OperationCanceledException">
        /// Exception thrown on submit cancellation
        /// </exception>
        private async ValueTask PushEncryptedPacket(EncryptedPacket dataPacket, CancellationToken token)
        {
            ICdmInstance cdmInstance = dataPacket.CdmInstance;

            if (cdmInstance == null)
            {
                throw new InvalidOperationException("Decrypt called without CdmInstance");
            }

            Task sessionsInitializationsTask = cdmInstance.WaitForAllSessionsInitializations(token);

            if (!sessionsInitializationsTask.IsCompleted)
            {
                logger.Info($"{streamType}: DRM Initialization incomplete");
                _bufferingSubject.OnNext(true);
                await sessionsInitializationsTask;
                _bufferingSubject.OnNext(false);

                logger.Info($"{streamType}: DRM Initialization complete");
            }

            using (var decryptedPacket = await cdmInstance.DecryptPacket(dataPacket, token) as DecryptedEMEPacket)
            {
                // Continue pushing packet till success or terminal failure
                for (;;)
                {
                    var submitStatus = player.Submit(decryptedPacket);

                    logger.Debug(
                        $"{decryptedPacket.StreamType}: ({submitStatus}) PTS: {decryptedPacket.Pts} Duration:" +
                        $"{decryptedPacket.Duration} Handle: {decryptedPacket.HandleSize.handle} " +
                        $"HandleSize: {decryptedPacket.HandleSize.size}");

                    if (submitStatus == ESPlayer.SubmitStatus.Success)
                    {
                        decryptedPacket.CleanHandle();
                        return;
                    }

                    if (!ShouldRetry(submitStatus))
                    {
                        throw new PacketSubmitException("Packet Submit Error", submitStatus);
                    }

                    await Task.Delay(CalculateDelay(submitStatus), token);
                }
            }
        }