/// <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 + "'.");
            }
        }
Ejemplo n.º 2
0
        /// <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));
        }
Ejemplo n.º 3
0
        /// <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 + "'.");
            }
        }
Ejemplo n.º 4
0
        /// <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;
        }