示例#1
0
        public void Dispose()
        {
            if (0 != Interlocked.Exchange(ref this._isDisposed, 1))
            {
                return;
            }
            bool   lockTaken = false;
            object obj       = null;

            try
            {
                Monitor.Enter(obj = this._packetsLock, ref lockTaken);
                while (this._packets.Count > 0)
                {
                    TsPesPacket tsPesPacket = this._packets.Dequeue();
                    if (null != tsPesPacket)
                    {
                        this._freePesPacket(tsPesPacket);
                    }
                }
            }
            finally
            {
                if (lockTaken)
                {
                    Monitor.Exit(obj);
                }
            }
            this._freePesPacket    = (Action <TsPesPacket>)null;
            this._bufferingManager = (IBufferingManager)null;
        }
示例#2
0
        public MediaReader(IBufferingManager bufferingManager, IMediaParserFactory mediaParserFactory, ISegmentManagerReaders segmentReaders, IBlockingPool<WorkBuffer> blockingPool)
        {
            if (null == bufferingManager)
                throw new ArgumentNullException(nameof(bufferingManager));
            if (null == mediaParserFactory)
                throw new ArgumentNullException(nameof(mediaParserFactory));

            _bufferingManager = bufferingManager;
            _mediaParserFactory = mediaParserFactory;
            _blockingPool = blockingPool;
            _segmentReaders = segmentReaders;
        }
 public void Initialize(IBufferingManager bufferingManager, Action <IProgramStreams> programStreamsHandler = null)
 {
     if (null == bufferingManager)
     {
         throw new ArgumentNullException("bufferingManager");
     }
     this._bufferingManager = bufferingManager;
     this._streamBuffer     = bufferingManager.CreateStreamBuffer(this._streamType);
     this._mediaStream      = new MediaStream((IConfigurationSource)this._configurator, this._streamBuffer, new Action <TsPesPacket>(this._tsPesPacketPool.FreePesPacket));
     this._mediaStreams     = (ICollection <IMediaParserMediaStream>) new MediaStream[1]
     {
         this._mediaStream
     };
 }
示例#4
0
        protected MediaDumpBase(Action<IProgramStreams> programStreamsHandler)
        {
            _programStreamsHandler = programStreamsHandler;
            BufferPool = new BufferPool(new DefaultBufferPoolParameters
            {
                BaseSize = 5 * 64 * 1024,
                Pools = 2
            });

            PacketPool = new TsPesPacketPool(BufferPool);
            _bufferingManager = new NullBufferingManager(PacketPool);

            _streamReader = new SignalTask(ReadStreams);
        }
示例#5
0
        public StreamBuffer(TsStreamType streamType, Action<TsPesPacket> freePesPacket, IBufferingManager bufferingManager)
        {
            if (null == streamType)
                throw new ArgumentNullException(nameof(streamType));
            if (null == freePesPacket)
                throw new ArgumentNullException(nameof(freePesPacket));
            if (null == bufferingManager)
                throw new ArgumentNullException(nameof(bufferingManager));

            _streamType = streamType;
            _freePesPacket = freePesPacket;
            _bufferingManager = bufferingManager;
            _isMedia = TsStreamType.StreamContents.Audio == _streamType.Contents || TsStreamType.StreamContents.Video == _streamType.Contents;
        }
示例#6
0
 public MediaReader(IBufferingManager bufferingManager, IMediaParserFactory mediaParserFactory, ISegmentManagerReaders segmentReaders, IBlockingPool <WorkBuffer> blockingPool)
 {
     if (null == bufferingManager)
     {
         throw new ArgumentNullException("bufferingManager");
     }
     if (null == mediaParserFactory)
     {
         throw new ArgumentNullException("mediaParserFactory");
     }
     this._bufferingManager   = bufferingManager;
     this._mediaParserFactory = mediaParserFactory;
     this._blockingPool       = blockingPool;
     this._segmentReaders     = segmentReaders;
 }
示例#7
0
        public void Initialize(IBufferingManager bufferingManager, Action <IProgramStreams> programStreamsHandler = null)
        {
            if (null == bufferingManager)
            {
                throw new ArgumentNullException("bufferingManager");
            }
            this._bufferingManager = bufferingManager;
            Action <IProgramStreams> handler = programStreamsHandler ?? new Action <IProgramStreams>(TsMediaParser.DefaultProgramStreamsHandler);

            programStreamsHandler = (Action <IProgramStreams>)(pss =>
            {
                handler(pss);
                this._streamCount = new int?(Enumerable.Count <IProgramStream>((IEnumerable <IProgramStream>)pss.Streams, (Func <IProgramStream, bool>)(s => !s.BlockStream)));
            });
            this._tsDecoder.Initialize(new Func <TsStreamType, uint, IMediaStreamMetadata, TsPacketizedElementaryStream>(this.CreatePacketizedElementaryStream), programStreamsHandler);
        }
示例#8
0
 public StreamBuffer(TsStreamType streamType, Action <TsPesPacket> freePesPacket, IBufferingManager bufferingManager)
 {
     if (null == streamType)
     {
         throw new ArgumentNullException("streamType");
     }
     if (null == freePesPacket)
     {
         throw new ArgumentNullException("freePesPacket");
     }
     if (null == bufferingManager)
     {
         throw new ArgumentNullException("bufferingManager");
     }
     this._streamType       = streamType;
     this._freePesPacket    = freePesPacket;
     this._bufferingManager = bufferingManager;
     this._isMedia          = TsStreamType.StreamContents.Audio == this._streamType.Contents || TsStreamType.StreamContents.Video == this._streamType.Contents;
 }
示例#9
0
 public void Dispose()
 {
     if (0 != Interlocked.Exchange(ref this._isDisposed, 1))
     {
         return;
     }
     using (this._callbackReader)
         ;
     using (this._queueWorker)
         ;
     using (this._blockingPool)
         ;
     using (this._mediaParser)
         ;
     this._callbackReader   = (CallbackReader)null;
     this._queueWorker      = (QueueWorker <WorkBuffer>)null;
     this._blockingPool     = (IBlockingPool <WorkBuffer>)null;
     this._mediaParser      = (IMediaParser)null;
     this._bufferingManager = (IBufferingManager)null;
     this._segmentReaders   = (ISegmentManagerReaders)null;
 }
 protected virtual void Dispose(bool disposing)
 {
     if (!disposing)
     {
         return;
     }
     if (!object.Equals((object)default(TConfigurator), (object)this._configurator))
     {
         this._configurator.ConfigurationComplete -= new EventHandler(this.OnConfigurationComplete);
     }
     if (null != this.ConfigurationComplete)
     {
         Debug.WriteLine("MediaParserBase<>.Dispose(bool) ConfigurationComplete event is still subscribed");
         this.ConfigurationComplete = (EventHandler)null;
     }
     using (this._streamBuffer)
         ;
     using (this._mediaStream)
         ;
     this._mediaStreams     = (ICollection <IMediaParserMediaStream>)null;
     this._mediaStream      = (MediaStream)null;
     this._bufferingManager = (IBufferingManager)null;
     this._streamBuffer     = (IStreamBuffer)null;
 }
        private async Task SimplePlayAsync(ContentType contentType, IWebReader webReader, IWebStreamResponse webStreamResponse, WebResponse webResponse, TaskCompletionSource <bool> configurationTaskCompletionSource, CancellationToken cancellationToken)
        {
            try
            {
                this._mediaStreamConfigurator.Initialize();
                this._mediaStreamConfigurator.MediaManager = (IMediaManager)this;
                IMediaParser mediaParser = await this._mediaParserFactory.CreateAsync((IMediaParserParameters) new MediaParserParameters(), contentType, cancellationToken).ConfigureAwait(false);

                if (null == mediaParser)
                {
                    throw new NotSupportedException("Unsupported content type: " + (object)contentType);
                }
                this.State = MediaManagerState.Opening;
                EventHandler configurationComplete = (EventHandler)null;
                configurationComplete = (EventHandler)((sender, args) =>
                {
                    mediaParser.ConfigurationComplete -= configurationComplete;
                    configurationTaskCompletionSource.TrySetResult(true);
                });
                mediaParser.ConfigurationComplete += configurationComplete;
                using (IBufferingManager bufferingManager = this._bufferingManagerFactory())
                {
                    SingleStreamMediaManager.QueueThrottle throttle = new SingleStreamMediaManager.QueueThrottle();
                    bufferingManager.Initialize((IQueueThrottling)throttle, new Action(this._mediaStreamConfigurator.CheckForSamples));
                    mediaParser.Initialize(bufferingManager, (Action <IProgramStreams>)null);
                    IStreamMetadata streamMetadata = this._webMetadataFactory.CreateStreamMetadata(webResponse, (ContentType)null);
                    mediaParser.InitializeStream(streamMetadata);
                    Task reader = (Task)null;
                    try
                    {
                        using (webReader)
                        {
                            try
                            {
                                if (null == webStreamResponse)
                                {
                                    webStreamResponse = await webReader.GetWebStreamAsync((Uri)null, false, cancellationToken, (Uri)null, new long?(), new long?(), webResponse).ConfigureAwait(false);
                                }
                                reader = this.ReadResponseAsync(mediaParser, webStreamResponse, webResponse, throttle, cancellationToken);
                                Task task = await TaskEx.WhenAny((Task)configurationTaskCompletionSource.Task, CancellationTokenExtensions.AsTask(cancellationToken)).ConfigureAwait(false);

                                cancellationToken.ThrowIfCancellationRequested();
                                await MediaStreamSourceExtensions.PlayAsync(this._mediaStreamConfigurator, (IEnumerable <IMediaParserMediaStream>) mediaParser.MediaStreams, new TimeSpan?(), cancellationToken).ConfigureAwait(false);

                                this.State = MediaManagerState.Playing;
                                await reader.ConfigureAwait(false);

                                reader = (Task)null;
                            }
                            finally
                            {
                                if (null != webStreamResponse)
                                {
                                    webStreamResponse.Dispose();
                                }
                            }
                        }
                    }
                    catch (OperationCanceledException ex)
                    {
                    }
                    catch (Exception ex)
                    {
                        string message = ExceptionExtensions.ExtendedMessage(ex);
                        Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() failed: " + message);
                        this.SetMediaState(MediaManagerState.Error, message);
                    }
                    this.State = MediaManagerState.Closing;
                    if (null != reader)
                    {
                        try
                        {
                            await reader.ConfigureAwait(false);
                        }
                        catch (OperationCanceledException ex)
                        {
                        }
                        catch (Exception ex)
                        {
                            Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() reader failed: " + ExceptionExtensions.ExtendedMessage(ex));
                        }
                    }
                    mediaParser.ConfigurationComplete -= configurationComplete;
                    mediaParser.EnableProcessing       = false;
                    mediaParser.FlushBuffers();
                    bufferingManager.Flush();
                    bufferingManager.Shutdown((IQueueThrottling)throttle);
                    await this._mediaStreamConfigurator.CloseAsync().ConfigureAwait(false);
                }
            }
            catch (Exception ex)
            {
                Debug.WriteLine("SingleStreamMediaManager.SimplePlayAsync() cleanup failed: " + ExceptionExtensions.ExtendedMessage(ex));
            }
            this._mediaStreamConfigurator.MediaManager = (IMediaManager)null;
            if (!configurationTaskCompletionSource.Task.IsCompleted)
            {
                configurationTaskCompletionSource.TrySetCanceled();
            }
            this.State = MediaManagerState.Closed;
            await this._reportStateTask.WaitAsync().ConfigureAwait(false);
        }
示例#12
0
        public void Dispose()
        {
            if (0 != Interlocked.Exchange(ref _isDisposed, 1))
                return;

            using (_callbackReader)
            { }

            using (_queueWorker)
            { }

            using (_blockingPool)
            { }

            using (_mediaParser)
            { }

            _callbackReader = null;
            _queueWorker = null;
            _blockingPool = null;
            _mediaParser = null;
            _bufferingManager = null;
            _segmentReaders = null;
        }
示例#13
0
        public void Dispose()
        {
            var wasDisposed = Interlocked.Exchange(ref _isDisposed, 1);

            if (0 != wasDisposed)
                return;

            lock (_packetsLock)
            {
                while (_packets.Count > 0)
                {
                    var packet = _packets.Dequeue();

                    if (null == packet)
                        continue;

                    _freePesPacket(packet);
                }
            }

            _freePesPacket = null;
            _bufferingManager = null;
        }
示例#14
0
        public void Initialize(IBufferingManager bufferingManager, Action<IProgramStreams> programStreamsHandler = null)
        {
            if (null == bufferingManager)
                throw new ArgumentNullException(nameof(bufferingManager));

            _bufferingManager = bufferingManager;

            var handler = programStreamsHandler ?? DefaultProgramStreamsHandler;

            programStreamsHandler = pss =>
            {
                handler(pss);

                _streamCount = pss.Streams.Count(s => !s.BlockStream);
            };

            _tsDecoder.Initialize(CreatePacketizedElementaryStream, programStreamsHandler);
        }