/// <summary>
/// Closes this source, sends BYE to remote party.
/// </summary>
/// <param name="closeReason">Stream closing reason text what is reported to the remote party. Value null means not specified.</param>
/// <exception cref="ObjectDisposedException">Is raised when this class is Disposed and this method is accessed.</exception>
internal override void Close(string closeReason)
{
if (State == RTP_SourceState.Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
RTCP_CompoundPacket packet = new RTCP_CompoundPacket();
RTCP_Packet_RR rr = new RTCP_Packet_RR();
rr.SSRC = SSRC;
packet.Packets.Add(rr);
RTCP_Packet_BYE bye = new RTCP_Packet_BYE();
bye.Sources = new[] { SSRC };
if (!string.IsNullOrEmpty(closeReason))
{
bye.LeavingReason = closeReason;
}
packet.Packets.Add(bye);
// Send packet.
Session.SendRtcpPacket(packet);
base.Close(closeReason);
}
/// <summary>
/// Sends specified application packet to the RTP session target(s).
/// </summary>
/// <exception cref="ObjectDisposedException">Is raised when this class is Disposed and this method is accessed.</exception>
/// <param name="packet">Is raised when <b>packet</b> is null reference.</param>
public void SendApplicationPacket(RTCP_Packet_APP packet)
{
if (State == RTP_SourceState.Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (packet == null)
{
throw new ArgumentNullException("packet");
}
packet.Source = SSRC;
RTCP_CompoundPacket p = new RTCP_CompoundPacket();
RTCP_Packet_RR rr = new RTCP_Packet_RR();
rr.SSRC = SSRC;
p.Packets.Add(packet);
// Send APP packet.
Session.SendRtcpPacket(p);
}
/// <summary>
/// Parses 1 RTCP packet from the specified buffer.
/// </summary>
/// <param name="buffer">Buffer which contains RTCP packet.</param>
/// <param name="offset">Offset in buffer.</param>
/// <returns>Returns parsed RTCP packet.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>buffer</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public static RTCP_Packet Parse(byte[] buffer, ref int offset)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset < 0)
{
throw new ArgumentException("Argument 'offset' value must be >= 0.");
}
/* RFC 3550 RTCP header.
* 0 1 2 3
* 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
* header |V=2|P| XX | type | length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
int type = buffer[offset + 1];
// SR
if (type == RTCP_PacketType.SR)
{
RTCP_Packet_SR packet = new RTCP_Packet_SR();
packet.ParseInternal(buffer, ref offset);
return(packet);
}
// RR
else if (type == RTCP_PacketType.RR)
{
RTCP_Packet_RR packet = new RTCP_Packet_RR();
packet.ParseInternal(buffer, ref offset);
return(packet);
}
// SDES
else if (type == RTCP_PacketType.SDES)
{
RTCP_Packet_SDES packet = new RTCP_Packet_SDES();
packet.ParseInternal(buffer, ref offset);
return(packet);
}
// BYE
else if (type == RTCP_PacketType.BYE)
{
RTCP_Packet_BYE packet = new RTCP_Packet_BYE();
packet.ParseInternal(buffer, ref offset);
return(packet);
}
// APP
else if (type == RTCP_PacketType.APP)
{
RTCP_Packet_APP packet = new RTCP_Packet_APP();
packet.ParseInternal(buffer, ref offset);
return(packet);
}
else
{
// We need to move offset.
offset += 2;
int length = buffer[offset++] << 8 | buffer[offset++];
offset += length;
throw new ArgumentException("Unknown RTCP packet type '" + type + "'.");
}
}
/// <summary>
/// Parses 1 RTCP packet from the specified buffer.
/// </summary>
/// <param name="buffer">Buffer which contains RTCP packet.</param>
/// <param name="offset">Offset in buffer.</param>
/// <returns>Returns parsed RTCP packet.</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>buffer</b> is null.</exception>
/// <exception cref="ArgumentException">Is raised when any of the arguments has invalid value.</exception>
public static RTCP_Packet Parse(byte[] buffer, ref int offset)
{
if (buffer == null)
{
throw new ArgumentNullException("buffer");
}
if (offset < 0)
{
throw new ArgumentException("Argument 'offset' value must be >= 0.");
}
/* RFC 3550 RTCP header.
0 1 2 3
0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1 2 3 4 5 6 7 8 9 0 1
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
header |V=2|P| XX | type | length |
+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+-+
*/
int type = buffer[offset + 1];
// SR
if (type == RTCP_PacketType.SR)
{
RTCP_Packet_SR packet = new RTCP_Packet_SR();
packet.ParseInternal(buffer, ref offset);
return packet;
}
// RR
else if (type == RTCP_PacketType.RR)
{
RTCP_Packet_RR packet = new RTCP_Packet_RR();
packet.ParseInternal(buffer, ref offset);
return packet;
}
// SDES
else if (type == RTCP_PacketType.SDES)
{
RTCP_Packet_SDES packet = new RTCP_Packet_SDES();
packet.ParseInternal(buffer, ref offset);
return packet;
}
// BYE
else if (type == RTCP_PacketType.BYE)
{
RTCP_Packet_BYE packet = new RTCP_Packet_BYE();
packet.ParseInternal(buffer, ref offset);
return packet;
}
// APP
else if (type == RTCP_PacketType.APP)
{
RTCP_Packet_APP packet = new RTCP_Packet_APP();
packet.ParseInternal(buffer, ref offset);
return packet;
}
else
{
// We need to move offset.
offset += 2;
int length = buffer[offset++] << 8 | buffer[offset++];
offset += length;
throw new ArgumentException("Unknown RTCP packet type '" + type + "'.");
}
}
/// <summary>
/// Closes RTP session, sends BYE with optional reason text to remote targets.
/// </summary>
/// <param name="closeReason">Close reason. Value null means not specified.</param>
/// <exception cref="ObjectDisposedException">Is raised when this class is Disposed and this method is accessed.</exception>
public void Close(string closeReason)
{
if (m_IsDisposed)
{
throw new ObjectDisposedException(GetType().Name);
}
// Generate BYE packet(s).
RTCP_CompoundPacket compundPacket = new RTCP_CompoundPacket();
RTCP_Packet_RR rr = new RTCP_Packet_RR();
rr.SSRC = m_pRtcpSource.SSRC;
compundPacket.Packets.Add(rr);
int sourcesProcessed = 0;
while (sourcesProcessed < m_pLocalSources.Count)
{
uint[] sources = new uint[Math.Min(m_pLocalSources.Count - sourcesProcessed, 31)];
for (int i = 0; i < sources.Length; i++)
{
sources[i] = m_pLocalSources[sourcesProcessed].SSRC;
sourcesProcessed++;
}
RTCP_Packet_BYE bye = new RTCP_Packet_BYE();
bye.Sources = sources;
compundPacket.Packets.Add(bye);
}
// Send BYE.
SendRtcpPacket(compundPacket);
OnClosed();
Dispose();
}
/// <summary>
/// Sends RTCP report.
/// </summary>
private void SendRtcp()
{
/* RFC 3550 6.4 Sender and Receiver Reports
RTP receivers provide reception quality feedback using RTCP report
packets which may take one of two forms depending upon whether or not
the receiver is also a sender. The only difference between the
sender report (SR) and receiver report (RR) forms, besides the packet
type code, is that the sender report includes a 20-byte sender
information section for use by active senders. The SR is issued if a
site has sent any data packets during the interval since issuing the
last report or the previous one, otherwise the RR is issued.
Both the SR and RR forms include zero or more reception report
blocks, one for each of the synchronization sources from which this
receiver has received RTP data packets since the last report.
Reports are not issued for contributing sources listed in the CSRC
list. Each reception report block provides statistics about the data
received from the particular source indicated in that block. Since a
maximum of 31 reception report blocks will fit in an SR or RR packet,
additional RR packets SHOULD be stacked after the initial SR or RR
packet as needed to contain the reception reports for all sources
heard during the interval since the last report. If there are too
many sources to fit all the necessary RR packets into one compound
RTCP packet without exceeding the MTU of the network path, then only
the subset that will fit into one MTU SHOULD be included in each
interval. The subsets SHOULD be selected round-robin across multiple
intervals so that all sources are reported.
*/
bool we_sent = false;
try
{
m_pRtcpSource.SetLastRtcpPacket(DateTime.Now);
RTCP_CompoundPacket compundPacket = new RTCP_CompoundPacket();
RTCP_Packet_RR rr = null;
// Find active send streams.
List<RTP_SendStream> activeSendStreams = new List<RTP_SendStream>();
foreach (RTP_SendStream stream in SendStreams)
{
if (stream.RtcpCyclesSinceWeSent < 2)
{
activeSendStreams.Add(stream);
we_sent = true;
}
// Notify stream about RTCP cycle.
stream.RtcpCycle();
}
#region SR(s) / RR
// We are sender.
if (we_sent)
{
// Create SR for each active send stream.
for (int i = 0; i < activeSendStreams.Count; i++)
{
RTP_SendStream sendStream = activeSendStreams[i];
RTCP_Packet_SR sr = new RTCP_Packet_SR(sendStream.Source.SSRC);
sr.NtpTimestamp = RTP_Utils.DateTimeToNTP64(DateTime.Now);
sr.RtpTimestamp = m_pRtpClock.RtpTimestamp;
sr.SenderPacketCount = (uint) sendStream.RtpPacketsSent;
sr.SenderOctetCount = (uint) sendStream.RtpBytesSent;
compundPacket.Packets.Add(sr);
}
}
// We are receiver.
else
{
rr = new RTCP_Packet_RR();
rr.SSRC = m_pRtcpSource.SSRC;
compundPacket.Packets.Add(rr);
// Report blocks added later.
}
#endregion
#region SDES
RTCP_Packet_SDES sdes = new RTCP_Packet_SDES();
// Add default SSRC.
RTCP_Packet_SDES_Chunk sdesChunk = new RTCP_Packet_SDES_Chunk(m_pRtcpSource.SSRC,
m_pSession.LocalParticipant.
CNAME);
// Add next optional SDES item, if any. (We round-robin optional items)
m_pSession.LocalParticipant.AddNextOptionalSdesItem(sdesChunk);
sdes.Chunks.Add(sdesChunk);
// Add all active send streams SSRC -> CNAME. This enusres that all send streams will be mapped to participant.
foreach (RTP_SendStream stream in activeSendStreams)
{
sdes.Chunks.Add(new RTCP_Packet_SDES_Chunk(stream.Source.SSRC,
m_pSession.LocalParticipant.CNAME));
}
compundPacket.Packets.Add(sdes);
#endregion
#region RR filling
/* RR reporting:
Report up to 31 active senders, if more senders, reoprt next with next interval.
Report oldest not reported first,then ventually all sources will be reported with this algorythm.
*/
RTP_Source[] senders = Senders;
DateTime[] acitveSourceRRTimes = new DateTime[senders.Length];
RTP_ReceiveStream[] activeSenders = new RTP_ReceiveStream[senders.Length];
int activeSenderCount = 0;
foreach (RTP_Source sender in senders)
{
// Remote sender sent RTP data during last RTCP interval.
if (!sender.IsLocal && sender.LastRtpPacket > m_RtcpLastTransmission)
{
acitveSourceRRTimes[activeSenderCount] = sender.LastRRTime;
activeSenders[activeSenderCount] = ((RTP_Source_Remote) sender).Stream;
activeSenderCount++;
}
}
// Create RR is SR report and no RR created yet.
if (rr == null)
{
rr = new RTCP_Packet_RR();
rr.SSRC = m_pRtcpSource.SSRC;
compundPacket.Packets.Add(rr);
}
// Sort ASC.
Array.Sort(acitveSourceRRTimes, activeSenders, 0, activeSenderCount);
// Add up to 31 oldest not reported sources to report.
for (int i = 1; i < 31; i++)
{
if ((activeSenderCount - i) < 0)
{
break;
}
rr.ReportBlocks.Add(activeSenders[activeSenderCount - i].CreateReceiverReport());
}
#endregion
// Send RTPC packet.
SendRtcpPacket(compundPacket);
// Timeout conflicting transport addresses, if not conflicting any more.
lock (m_pConflictingEPs)
{
string[] keys = new string[m_pConflictingEPs.Count];
m_pConflictingEPs.Keys.CopyTo(keys, 0);
foreach (string key in keys)
{
if (m_pConflictingEPs[key].AddMinutes(3) < DateTime.Now)
{
m_pConflictingEPs.Remove(key);
}
}
}
// Since we must check timing out sources at least once per RTCP interval, so we
// check this before sending RTCP.
TimeOutSsrc();
}
catch (Exception x)
{
m_pSession.OnError(x);
}
m_RtcpLastTransmission = DateTime.Now;
// Schedule next RTCP sending.
Schedule(ComputeRtcpTransmissionInterval(m_pMembers.Count,
m_pSenders.Count,
m_Bandwidth*0.25,
we_sent,
m_RtcpAvgPacketSize,
false));
}
/// <summary>
/// Gets or creates source. This method also does RFC 3550 8.2 "Collision Resolution and Loop Detection".
/// </summary>
/// <param name="rtcp_rtp">If true <b>src</b> is RTCP identifier, otherwise RTP identifier.</param>
/// <param name="src">Source SSRC or CSRC identifier.</param>
/// <param name="cname">RTCP SDES chunk CNAME. Must be passed only if <b>src</b> if from RTCP SDES chunk.</param>
/// <param name="packetEP">Packet sender end point.</param>
/// <returns>Returns specified source. Returns null if source has "collision or loop".</returns>
/// <exception cref="ArgumentNullException">Is raised when <b>packetEP</b> is null reference.</exception>
private RTP_Source_Remote GetOrCreateSource(bool rtcp_rtp, uint src, string cname, IPEndPoint packetEP)
{
if (packetEP == null)
{
throw new ArgumentNullException("packetEP");
}
/* RFC 3550 8.2.
if(SSRC or CSRC identifier is not found in the source identifier table){
create a new entry storing the data or control source transport address, the SSRC or CSRC and other state;
}
else if(table entry was created on receipt of a control packet and this is the first data packet or vice versa){
store the source transport address from this packet;
}
else if(source transport address from the packet does not match the one saved in the table entry for this identifier){
// An identifier collision or a loop is indicated
if(source identifier is not the participant's own){
// OPTIONAL error counter step
if(source identifier is from an RTCP SDES chunk containing a CNAME item that differs from the CNAME in the table entry){
count a third-party collision;
}
else{
count a third-party loop;
}
abort processing of data packet or control element;
// MAY choose a different policy to keep new source
}
// A collision or loop of the participant's own packets
else if(source transport address is found in the list of conflicting data or control source transport addresses){
// OPTIONAL error counter step
if(source identifier is not from an RTCP SDES chunk containing a CNAME item or CNAME is the participant's own){
count occurrence of own traffic looped;
}
mark current time in conflicting address list entry;
abort processing of data packet or control element;
}
// New collision, change SSRC identifier
else{
log occurrence of a collision;
create a new entry in the conflicting data or control source transport address list and mark current time;
send an RTCP BYE packet with the old SSRC identifier;
choose a new SSRC identifier;
create a new entry in the source identifier table with the old SSRC plus the source transport address from
the data or control packet being processed;
}
}
*/
RTP_Source source = null;
lock (m_pMembers)
{
m_pMembers.TryGetValue(src, out source);
// SSRC or CSRC identifier is not found in the source identifier table.
if (source == null)
{
source = new RTP_Source_Remote(this, src);
if (rtcp_rtp)
{
source.SetRtcpEP(packetEP);
}
else
{
source.SetRtpEP(packetEP);
}
m_pMembers.Add(src, source);
}
// Table entry was created on receipt of a control packet and this is the first data packet or vice versa.
else if ((rtcp_rtp ? source.RtcpEP : source.RtpEP) == null)
{
if (rtcp_rtp)
{
source.SetRtcpEP(packetEP);
}
else
{
source.SetRtpEP(packetEP);
}
}
// Source transport address from the packet does not match the one saved in the table entry for this identifier.
else if (!packetEP.Equals((rtcp_rtp ? source.RtcpEP : source.RtpEP)))
{
// Source identifier is not the participant's own.
if (!source.IsLocal)
{
if (cname != null && cname != source.CName)
{
m_RemoteCollisions++;
}
else
{
m_RemotePacketsLooped++;
}
return null;
}
// A collision or loop of the participant's own packets.
else if (m_pConflictingEPs.ContainsKey(packetEP.ToString()))
{
if (cname == null || cname == source.CName)
{
m_LocalPacketsLooped++;
}
m_pConflictingEPs[packetEP.ToString()] = DateTime.Now;
return null;
}
// New collision, change SSRC identifier.
else
{
m_LocalCollisions++;
m_pConflictingEPs.Add(packetEP.ToString(), DateTime.Now);
// Remove SSRC from members,senders. Choose new SSRC, CNAME new and BYE old.
m_pMembers.Remove(source.SSRC);
m_pSenders.Remove(source.SSRC);
uint oldSSRC = source.SSRC;
source.GenerateNewSSRC();
// Ensure that new SSRC is not in use, if so repaeat while not conflicting SSRC.
while (m_pMembers.ContainsKey(source.SSRC))
{
source.GenerateNewSSRC();
}
m_pMembers.Add(source.SSRC, source);
RTCP_CompoundPacket compoundPacket = new RTCP_CompoundPacket();
RTCP_Packet_RR rr = new RTCP_Packet_RR();
rr.SSRC = m_pRtcpSource.SSRC;
compoundPacket.Packets.Add(rr);
RTCP_Packet_SDES sdes = new RTCP_Packet_SDES();
RTCP_Packet_SDES_Chunk sdes_chunk = new RTCP_Packet_SDES_Chunk(source.SSRC,
m_pSession.
LocalParticipant.
CNAME);
sdes.Chunks.Add(sdes_chunk);
compoundPacket.Packets.Add(sdes);
RTCP_Packet_BYE bye = new RTCP_Packet_BYE();
bye.Sources = new[] {oldSSRC};
bye.LeavingReason = "Collision, changing SSRC.";
compoundPacket.Packets.Add(bye);
SendRtcpPacket(compoundPacket);
//----------------------------------------------------------------------
// Add new source to members, it's not conflicting any more, we changed SSRC.
source = new RTP_Source_Remote(this, src);
if (rtcp_rtp)
{
source.SetRtcpEP(packetEP);
}
else
{
source.SetRtpEP(packetEP);
}
m_pMembers.Add(src, source);
}
}
}
return (RTP_Source_Remote) source;
}
/// <summary>
/// Closes this source, sends BYE to remote party.
/// </summary>
/// <param name="closeReason">Stream closing reason text what is reported to the remote party. Value null means not specified.</param>
/// <exception cref="ObjectDisposedException">Is raised when this class is Disposed and this method is accessed.</exception>
internal override void Close(string closeReason)
{
if (State == RTP_SourceState.Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
RTCP_CompoundPacket packet = new RTCP_CompoundPacket();
RTCP_Packet_RR rr = new RTCP_Packet_RR();
rr.SSRC = SSRC;
packet.Packets.Add(rr);
RTCP_Packet_BYE bye = new RTCP_Packet_BYE();
bye.Sources = new[] {SSRC};
if (!string.IsNullOrEmpty(closeReason))
{
bye.LeavingReason = closeReason;
}
packet.Packets.Add(bye);
// Send packet.
Session.SendRtcpPacket(packet);
base.Close(closeReason);
}
/// <summary>
/// Sends specified application packet to the RTP session target(s).
/// </summary>
/// <exception cref="ObjectDisposedException">Is raised when this class is Disposed and this method is accessed.</exception>
/// <param name="packet">Is raised when <b>packet</b> is null reference.</param>
public void SendApplicationPacket(RTCP_Packet_APP packet)
{
if (State == RTP_SourceState.Disposed)
{
throw new ObjectDisposedException(GetType().Name);
}
if (packet == null)
{
throw new ArgumentNullException("packet");
}
packet.Source = SSRC;
RTCP_CompoundPacket p = new RTCP_CompoundPacket();
RTCP_Packet_RR rr = new RTCP_Packet_RR();
rr.SSRC = SSRC;
p.Packets.Add(packet);
// Send APP packet.
Session.SendRtcpPacket(p);
}