public override void PacketHandler(TsPesPacket packet)
{
base.PacketHandler(packet);
if (null == packet)
{
_nextHandler(null);
return;
}
// Reject garbage packet
if (packet.Length < 1)
{
_pesPacketPool.FreePesPacket(packet);
return;
}
if (!_foundframe)
{
_configurator.Configure();
_foundframe = true;
}
_nextHandler(packet);
}
public virtual void PacketHandler(TsPesPacket packet)
{
return;
#pragma warning disable 162
if (null == packet)
Debug.WriteLine("PES {0}/{1} End-of-stream", StreamType.Contents, Pid);
else
{
#if DEBUG
Debug.WriteLine("PES({0}) {1}/{2} PTS {3} Length {4}",
packet.PacketId,
StreamType.Contents, Pid,
packet.PresentationTimestamp, packet.Length);
#endif
}
#pragma warning restore 162
}
public override TimeSpan? GetDuration(TsPesPacket packet)
{
if (packet.Duration.HasValue)
return packet.Duration;
var duration = TimeSpan.Zero;
var length = packet.Length;
var endOffset = packet.Index + length;
int nextFrameOffset;
var skipLength = 0;
for (var i = packet.Index; i < endOffset; i += nextFrameOffset, length -= nextFrameOffset)
{
if (_frameHeader.Parse(packet.Buffer, i, length))
{
duration += _frameHeader.Duration;
if (_frameHeader.HeaderOffset > 0)
Debug.WriteLine("AudioStreamHandler.GetDuration() skipping {0} bytes before frame", _frameHeader.HeaderOffset);
nextFrameOffset = _frameHeader.HeaderOffset + _frameHeader.FrameLength;
skipLength = 0;
}
else
{
if (length > _frameHeader.HeaderOffset + _minimumPacketSize)
{
nextFrameOffset = _frameHeader.HeaderOffset + 1;
skipLength += nextFrameOffset;
continue;
}
Debug.WriteLine("AudioStreamHandler.GetDuration() unable to find frame, skipping {0} bytes", length + skipLength);
break;
}
}
packet.Duration = duration;
return duration;
}
public override void PacketHandler(TsPesPacket packet)
{
base.PacketHandler(packet);
if (null == packet)
{
if (null != Parser)
Parser.FlushBuffers();
if (null != NextHandler)
NextHandler(null);
return;
}
if (null != Parser)
{
Parser.Position = packet.PresentationTimestamp;
Parser.ProcessData(packet.Buffer, packet.Index, packet.Length);
_pesPacketPool.FreePesPacket(packet);
return;
}
//Reject garbage packet
if (packet.Length < _minimumPacketSize)
{
_pesPacketPool.FreePesPacket(packet);
return;
}
if (!_isConfigured)
{
if (_frameHeader.Parse(packet.Buffer, packet.Index, packet.Length, true))
{
_isConfigured = true;
AudioConfigurator.Configure(_frameHeader);
}
}
NextHandler(packet);
}
public void EnqueuePacket(TsPesPacket packet)
{
_packets.Add(packet);
}
public override void PacketHandler(TsPesPacket packet)
{
base.PacketHandler(packet);
_nextHandler(packet);
}
protected virtual void SubmitFrame()
{
Debug.Assert(_index >= _startIndex, "_index less than _startIndex");
var length = _index - _startIndex;
if (length > 0)
{
TsPesPacket packet;
if (_index + 128 >= _packet.Buffer.Length)
{
packet = _packet;
_packet = null;
packet.Length = length;
packet.Index = _startIndex;
}
else
packet = _pesPacketPool.CopyPesPacket(_packet, _startIndex, length);
if (!Position.HasValue)
Position = StartPosition;
packet.PresentationTimestamp = Position.Value;
packet.Duration = _frameHeader.Duration;
Position += _frameHeader.Duration;
_submitPacket(packet);
_hasSeenValidFrames = true;
_badBytes = 0;
}
_startIndex = _index;
EnsureBufferSpace(128);
}
void FreeBuffer()
{
if (null != _packet)
{
var packet = _packet;
_packet = null;
packet.Length = 0;
_pesPacketPool.FreePesPacket(packet);
}
_startIndex = 0;
_index = 0;
}
protected void EnsureBufferSpace(int length)
{
if (null == _packet)
{
_index = 0;
_startIndex = 0;
_packet = null;
_packet = CreatePacket(length);
return;
}
if (_index + length <= _packet.Buffer.Length)
return;
var newPacket = CreatePacket(length);
if (_index > _startIndex)
{
// Copy the partial frame to the new buffer.
_index -= _startIndex;
Array.Copy(_packet.Buffer, _startIndex, newPacket.Buffer, 0, _index);
}
else
_index = 0;
_startIndex = 0;
_packet.Length = 0;
_pesPacketPool.FreePesPacket(_packet);
_packet = newPacket;
}
public override void PacketHandler(TsPesPacket packet)
{
if (null == packet)
{
if (null != _stream)
_stream.Close();
_hash.TransformFinalBlock(FakeBuffer, 0, 0);
_streamHash = _hash.Hash;
Console.WriteLine("PID{0} {1}: {2}", Pid, StreamType.Contents, StreamType.Description);
Console.WriteLine("Hash:");
var count = 0;
foreach (var b in _streamHash)
{
Console.Write(b.ToString("x2"));
++count;
if (0 == (count & 3))
{
if (0 == (count & 0x0f))
Console.WriteLine();
else
Console.Write(' ');
}
}
}
else
{
Task t = null;
if (null != _stream)
t = _stream.WriteAsync(packet.Buffer, packet.Index, packet.Length);
_hash.TransformBlock(packet.Buffer, packet.Index, packet.Length, null, 0);
if (packet.PresentationTimestamp < _timestamp)
Debug.WriteLine("Timestamp did not increase {0} -> {1}", _timestamp, packet.PresentationTimestamp);
_timestamp = packet.PresentationTimestamp;
if (null != t)
t.Wait();
}
var h = _nextHandler;
if (null != h)
h(packet);
}
public void ReportGetSampleCompleted(int streamType, IStreamSource streamSource, TsPesPacket packet)
{
if (null == packet)
{
Debug.WriteLine("SimulatedMediaElementManager.ReportGetSampleCompleted({0}) null packet", streamType);
return;
}
Debug.WriteLine("SimulatedMediaElementManager.ReportGetSampleCompleted({0}) at {1}/{2}", streamType, packet.PresentationTimestamp, packet.DecodeTimestamp);
var timestamp = packet.PresentationTimestamp;
var oldestTimestamp = TimeSpan.MaxValue;
var oldestIndex = -1;
lock (_lock)
{
SampleState sampleState;
if (!_streams.TryGetValue(streamType, out sampleState))
{
sampleState = new SampleState
{
IsPending = false,
Timestamp = timestamp
};
_streams[streamType] = sampleState;
}
else
{
sampleState.IsPending = false;
sampleState.Timestamp = timestamp;
}
foreach (var kv in _streams)
{
var sampleTimestamp = kv.Value.Timestamp;
if (sampleTimestamp >= oldestTimestamp)
continue;
oldestTimestamp = sampleTimestamp;
oldestIndex = kv.Key;
}
if (oldestIndex >= 0)
{
if (streamType != oldestIndex)
sampleState = _streams[oldestIndex];
if (sampleState.IsPending)
oldestIndex = -1;
else
sampleState.IsPending = true;
}
}
if (oldestIndex >= 0)
{
var t = Task.Run(async () =>
{
await Task.Delay((int)(10 * (1 + _random.GetRandomNumber()))).ConfigureAwait(false);
var mediaStreamSource = _mediaStreamConfigurator;
if (null != mediaStreamSource)
mediaStreamSource.GetSampleAsync(oldestIndex);
});
TaskCollector.Default.Add(t, "SimulatedMediaElementManager.ReportGetSampleCompleted");
}
}
public override void PacketHandler(TsPesPacket packet)
{
base.PacketHandler(packet);
if (null == packet)
{
_nextHandler(null);
return;
}
// Reject garbage packet
if (packet.Length < 1)
{
_pesPacketPool.FreePesPacket(packet);
return;
}
if (!_isConfigured)
{
_parser.Reset();
_parser.Parse(packet.Buffer, packet.Index, packet.Length);
_isConfigured = _configurator.IsConfigured;
}
_nextHandler(packet);
}
public virtual TimeSpan? GetDuration(TsPesPacket packet)
{
return packet.Duration;
}
public void FreeSample(TsPesPacket packet)
{
_freePesPacket(packet);
}
