protected PesStreamHandler(PesStreamParameters parameters)
{
if (null == parameters)
throw new ArgumentNullException(nameof(parameters));
StreamType = parameters.StreamType;
Pid = parameters.Pid;
}
protected PesStreamHandler(PesStreamParameters parameters)
{
if (null == parameters)
{
throw new ArgumentNullException(nameof(parameters));
}
StreamType = parameters.StreamType;
_pid = parameters.Pid;
}
protected PesStreamHandler(PesStreamParameters parameters)
{
if (null == parameters)
{
throw new ArgumentNullException("parameters");
}
this.StreamType = parameters.StreamType;
this.Pid = parameters.Pid;
}
protected AudioMediaParser(TsStreamType streamType, TConfigurator configurator, ITsPesPacketPool pesPacketPool, IShoutcastMetadataFilterFactory shoutcastMetadataFilterFactory, IMetadataSink metadataSink)
: base(streamType, configurator, pesPacketPool)
{
if (null == shoutcastMetadataFilterFactory)
{
throw new ArgumentNullException("shoutcastMetadataFilterFactory");
}
if (null == metadataSink)
{
throw new ArgumentNullException("metadataSink");
}
this._shoutcastMetadataFilterFactory = shoutcastMetadataFilterFactory;
this._metadataSink = metadataSink;
}
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;
}
public TsPacketizedElementaryStream(IBufferPool bufferPool, ITsPesPacketPool pesPacketPool, Action<TsPesPacket> packetHandler, TsStreamType streamType, uint pid)
{
if (null == bufferPool)
throw new ArgumentNullException(nameof(bufferPool));
if (null == pesPacketPool)
throw new ArgumentNullException(nameof(pesPacketPool));
_bufferPool = bufferPool;
_pesPacketPool = pesPacketPool;
_streamType = streamType;
_pid = pid;
_handler = packetHandler;
}
protected MediaParserBase(TsStreamType streamType, TConfigurator configurator, ITsPesPacketPool tsPesPacketPool)
{
if (null == streamType)
{
throw new ArgumentNullException("streamType");
}
if (object.ReferenceEquals((object)default(TConfigurator), (object)configurator))
{
throw new ArgumentNullException("configurator");
}
if (null == tsPesPacketPool)
{
throw new ArgumentNullException("tsPesPacketPool");
}
this._streamType = streamType;
this._configurator = configurator;
this._tsPesPacketPool = tsPesPacketPool;
this._configurator.ConfigurationComplete += new EventHandler(this.OnConfigurationComplete);
}
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;
}
private TsPacketizedElementaryStream CreatePacketizedElementaryStream(TsStreamType streamType, uint pid, IMediaStreamMetadata mediaStreamMetadata)
{
IStreamBuffer streamBuffer = this._bufferingManager.CreateStreamBuffer(streamType);
MediaStream mediaStream = (MediaStream)null;
PesStreamHandler pesHandler = this._pesHandlers.GetPesHandler(streamType, pid, mediaStreamMetadata, (Action <TsPesPacket>)(packet =>
{
if (null != mediaStream)
{
mediaStream.EnqueuePacket(packet);
}
else
{
if (null == packet)
{
return;
}
this._tsPesPacketPool.FreePesPacket(packet);
}
}));
TsPacketizedElementaryStream elementaryStream = new TsPacketizedElementaryStream(this._bufferPool, this._tsPesPacketPool, new Action <TsPesPacket>(pesHandler.PacketHandler), streamType, pid);
IConfigurationSource configurator = pesHandler.Configurator;
if (null != configurator)
{
EventHandler configuratorOnConfigurationComplete = (EventHandler)null;
configuratorOnConfigurationComplete = (EventHandler)((o, e) =>
{
configurator.ConfigurationComplete -= configuratorOnConfigurationComplete;
this.CheckConfigurationComplete();
});
configurator.ConfigurationComplete += configuratorOnConfigurationComplete;
}
mediaStream = new MediaStream(configurator, streamBuffer, new Action <TsPesPacket>(this._tsPesPacketPool.FreePesPacket));
this.AddMediaStream(mediaStream);
this._tsTimemestamp.RegisterMediaStream(mediaStream, new Func <TsPesPacket, TimeSpan?>(pesHandler.GetDuration));
if (null == configurator)
{
this.CheckConfigurationComplete();
}
return(elementaryStream);
}
public PesStreamHandler GetPesHandler(TsStreamType streamType, uint pid, IMediaStreamMetadata mediaStreamMetadata, Action <TsPesPacket> nextHandler)
{
PesStreamHandler handler;
if (this._handlers.TryGetValue(pid, out handler))
{
Debug.WriteLine("Found PES {0} stream ({1}) with PID {2}", (object)streamType.Contents, (object)streamType.Description, (object)pid);
}
else
{
Debug.WriteLine("Create PES {0} stream ({1}) with PID {2}", (object)streamType.Contents, (object)streamType.Description, (object)pid);
PesStreamParameters parameters = this._parameterFactory();
parameters.Pid = pid;
parameters.StreamType = streamType;
parameters.NextHandler = nextHandler;
parameters.MediaStreamMetadata = mediaStreamMetadata;
handler = this._handlerFactory.CreateHandler(parameters);
this._handlers[pid] = handler;
}
return(handler);
}
public IStreamBuffer CreateStreamBuffer(TsStreamType streamType)
{
this.ThrowIfDisposed();
StreamBuffer streamBuffer = new StreamBuffer(streamType, new Action <TsPesPacket>(this._packetPool.FreePesPacket), (IBufferingManager)this);
bool lockTaken = false;
object obj = null;
try
{
Monitor.Enter(obj = this._lock, ref lockTaken);
this._queues.Add((IBufferingQueue)streamBuffer);
this.ResizeStatuses();
}
finally
{
if (lockTaken)
{
Monitor.Exit(obj);
}
}
return((IStreamBuffer)streamBuffer);
}
public PesStreamHandler GetPesHandler(TsStreamType streamType, uint pid, IMediaStreamMetadata mediaStreamMetadata, Action<TsPesPacket> nextHandler)
{
PesStreamHandler handler;
if (_handlers.TryGetValue(pid, out handler))
Debug.WriteLine("Found PES {0} stream ({1}) with PID {2}", streamType.Contents, streamType.Description, pid);
else
{
Debug.WriteLine("Create PES {0} stream ({1}) with PID {2}", streamType.Contents, streamType.Description, pid);
var parameters = _parameterFactory();
parameters.Pid = pid;
parameters.StreamType = streamType;
parameters.NextHandler = nextHandler;
parameters.MediaStreamMetadata = mediaStreamMetadata;
handler = _handlerFactory.CreateHandler(parameters);
_handlers[pid] = handler;
}
return handler;
}
public IStreamBuffer CreateStreamBuffer(TsStreamType streamType)
{
return((IStreamBuffer) new StreamBuffer(streamType, new Action <TsPesPacket>(this._packetPool.FreePesPacket), (IBufferingManager)this));
}
public IStreamBuffer CreateStreamBuffer(TsStreamType streamType)
{
ThrowIfDisposed();
var buffer = new StreamBuffer(streamType, _packetPool.FreePesPacket, this);
lock (_lock)
{
_queues.Add(buffer);
ResizeStatuses();
}
return buffer;
}
TsPacketizedElementaryStream CreatePacketizedElementaryStream(TsStreamType streamType, uint pid, IMediaStreamMetadata mediaStreamMetadata)
{
var streamBuffer = _bufferingManager.CreateStreamBuffer(streamType);
MediaStream mediaStream = null;
var pesStreamHandler = _pesHandlers.GetPesHandler(streamType, pid, mediaStreamMetadata, packet =>
{
// ReSharper disable AccessToModifiedClosure
if (null != mediaStream)
mediaStream.EnqueuePacket(packet);
else if (null != packet)
_tsPesPacketPool.FreePesPacket(packet);
// ReSharper restore AccessToModifiedClosure
});
var pes = new TsPacketizedElementaryStream(_bufferPool, _tsPesPacketPool, pesStreamHandler.PacketHandler, streamType, pid);
var configurator = pesStreamHandler.Configurator;
if (null != configurator)
{
EventHandler configuratorOnConfigurationComplete = null;
configuratorOnConfigurationComplete = (o, e) =>
{
configurator.ConfigurationComplete -= configuratorOnConfigurationComplete;
CheckConfigurationComplete();
};
configurator.ConfigurationComplete += configuratorOnConfigurationComplete;
}
mediaStream = new MediaStream(configurator, streamBuffer, _tsPesPacketPool.FreePesPacket);
AddMediaStream(mediaStream);
_tsTimemestamp.RegisterMediaStream(mediaStream, pesStreamHandler.GetDuration);
if (null == configurator)
CheckConfigurationComplete();
return pes;
}
public TsPacketizedElementaryStream CreateStream(TsStreamType streamType, uint pid, IMediaStreamMetadata mediaStreamMetadata)
{
return _pesStreamFactory(streamType, pid, mediaStreamMetadata);
}
public IStreamBuffer CreateStreamBuffer(TsStreamType streamType)
{
return new StreamBuffer(streamType, _packetPool.FreePesPacket, this);
}
