public static RtcpPacket FromUdpBuffer(UdpBuffer buffer)
{
using (var stream = new MemoryStream(buffer.Data, 0, buffer.Size))
{
return FromStream(stream);
}
}
/// <summary>
/// Method to handle incoming data from <c>_listener</c>.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="buffer">The buffer.</param>
private void DataReceived(UdpListener listener, UdpBuffer buffer)
{
ThreadPool.QueueUserWorkItem(
delegate
{
try
{
var packet = RtpPacket.FromUdpBuffer(buffer);
lock (_receivingLock)
{
this._receivedPackets.Add(packet);
//signal that we got a packets
Monitor.Pulse(_receivingLock);
}
//if we dont care about sequence order, use these
if (packet.Marker)
{
OnMarkerReceived(packet);
}
OnPacketReceived(packet);
}
catch (InvalidDataException ex)
{
OnInvalidData(buffer);
Assert.Suppress(ex);
}
});
}
protected virtual void OnInvalidData(UdpBuffer buffer)
{
var handler = InvalidData;
if (handler != null)
{
handler(this, new EventArgs <UdpBuffer>(buffer));
}
}
public static RtpPacket FromUdpBuffer(UdpBuffer buffer)
{
var packet = new RtpPacket
{
RemoteEndPoint = buffer.RemoteEndPoint,
Size = buffer.Size,
Data = buffer.Data
};
packet.Parse();
return(packet);
}
protected void BeginReceive()
{
try
{
this._rwLock.AcquireReaderLock(Timeout.Infinite);
if (this.IsStarted)
{
// allocate a packet buffer
var buffer = new UdpBuffer(this.BufferSize);
// kick off an async read
this._client.BeginReceiveFrom(buffer.Data, 0, buffer.Data.Length, SocketFlags.None, ref buffer.RemoteEndPoint, EndReceive, buffer);
}
}
finally
{
this._rwLock.ReleaseReaderLock();
}
}
/// <summary>
/// Sends buffered information to a specified IPEndPoint
/// </summary>
/// <param name="buffer"></param>
public void Send(UdpBuffer buffer)
{
this.Send(buffer.Data, 0, buffer.Size, SocketFlags.None, buffer.RemoteEndPoint);
}
/// <summary>
/// Method to handle incoming data from <c>_listener</c>.
/// </summary>
/// <param name="listener">The listener.</param>
/// <param name="buffer">The buffer.</param>
private void DataReceived(UdpListener listener, UdpBuffer buffer)
{
ThreadPool.QueueUserWorkItem(
delegate
{
try
{
var packet = RtpPacket.FromUdpBuffer(buffer);
lock (_receivingLock)
{
this._receivedPackets.Add(packet);
//signal that we got a packets
Monitor.Pulse(_receivingLock);
}
//if we dont care about sequence order, use these
if (packet.Marker)
OnMarkerReceived(packet);
OnPacketReceived(packet);
}
catch (InvalidDataException ex)
{
OnInvalidData(buffer);
Assert.Suppress(ex);
}
});
}
protected virtual void OnInvalidData(UdpBuffer buffer)
{
var handler = InvalidData;
if (handler != null)
handler(this, new EventArgs<UdpBuffer>(buffer));
}
protected void BeginReceive()
{
try
{
this._rwLock.AcquireReaderLock(Timeout.Infinite);
if (this.IsStarted)
{
// allocate a packet buffer
var buffer = new UdpBuffer(this.BufferSize);
// kick off an async read
this._client.BeginReceiveFrom(buffer.Data, 0, buffer.Data.Length, SocketFlags.None, ref buffer.RemoteEndPoint, EndReceive, buffer);
}
}
finally
{
this._rwLock.ReleaseReaderLock();
}
}
/// <summary>
/// Sends buffered information to a specified IPEndPoint
/// </summary>
/// <param name="buffer"></param>
public void Send(UdpBuffer buffer)
{
this.Send(buffer.Data, 0, buffer.Size, SocketFlags.None, buffer.RemoteEndPoint);
}
protected virtual void OnDataReceived(object sender, UdpBuffer buffer)
{
ThreadPool.QueueUserWorkItem((data) =>
{
try
{
this.OnRtcpPacketReceived(RtcpPacket.FromUdpBuffer(buffer));
}
catch (InvalidDataException ex)
{
Trace.TraceError("Error parsing RTCP packet: {0}", ex.ToString());
}
});
}
