Example #1
0
        private void ProcessSRPacket(SrPacket packet, IPAddress ipAddress)
        {
            AddSsrcToIp(packet.SSRC, ipAddress);

            // TODO - Need SenderReportReceived(RtpStream, SenderReport) JVE
        }
Example #2
0
       private void Start()
       {
            //BufferChunk chunk = new BufferChunk(2048);
            CompoundPacket compoundPacket = new CompoundPacket();
            EndPoint endPoint = null;

            while (isRunning)
            {
                try
                {
                     compoundPacket.Reset();
                   udpListener.ReceiveFrom(compoundPacket.Buffer, out endPoint);

                    compoundPacket.ParseBuffer();
                    //IPAddress ipAddress = ((IPEndPoint)endPoint).Address;
                    IPEndPoint ipEndpoint = (IPEndPoint)endPoint;

                    // The compound packet enumerator destroys its list during enumeration,
                    // so we keep track of packets that have yet to be processed
                    IList<RtcpPacket> yetToBeProcessed = new List<RtcpPacket>();


                    String venueName = null;
                    //uint ssrc = 0;
                    long when = 0; // in units of "ticks"

                    // scan through the compound packet, looking for key pieces of meta-data
                    // first, look for the app packet that specifies the venue
                    // also, obtain the ssrc and the time stamp
                    
                    foreach (RtcpPacket packet in compoundPacket)
                    {
                        if (packet.PacketType == (byte)Rtcp.PacketType.APP)
                        {
                            AppPacket appPacket = new AppPacket(packet);
                            if (appPacket.Name.Equals(Rtcp.APP_PACKET_NAME) &&
                                appPacket.Subtype == Rtcp.VENUE_APP_PACKET_SUBTYPE)
                            {

                                BufferChunk chunk = new BufferChunk(appPacket.Data);
                                when = chunk.NextInt64();
                                venueName = chunk.NextUtf8String(chunk.Length);
                                int padIndex = venueName.IndexOf((char)0);
                                if (padIndex > 0)
                                    venueName = venueName.Substring(0, padIndex);
                            }
                        }
                        else
                        {
                            yetToBeProcessed.Add(packet);
                        }
                    }

                    if (venueName == null)
                        continue; // can't do anything if we don't know the venue for this packet
                    if (when == 0)
                        continue; // need a timestamp
                    
                    VenueState venueState = null;
                    
                    // compound operations must always be locked...
                    lock (venueStateMap)
                    {
                        if (!venueStateMap.ContainsKey(venueName))
                            venueState = new VenueState(venueName);
                        else venueState = venueStateMap[venueName];
                    }


                    // scan again, this time processing the RTCP packets
                    foreach (RtcpPacket packet in yetToBeProcessed)
                    {

                        switch (packet.PacketType)
                        {
                            case (byte)Rtcp.PacketType.SR:
                                {
                                    SrPacket sr = new SrPacket(packet);
                                    
                                    SenderData senderData = venueState.GetSenderState(sr.SSRC);
                                    senderData.Source = ipEndpoint;

                                    senderData.updateSenderState(sr.SenderReport, when);

                                    // this "refreshes" the host state (so that it won't expire)
                                    venueState.SenderData[sr.SSRC] = senderData;
                                    break;
                                }

                            case (byte)Rtcp.PacketType.RR:
                                {
                                    RrPacket rr = new RrPacket(packet);
                                    ReceiverData receiverData = venueState.GetReceiverData (ipEndpoint);

                                    // currently, we replace all receiver summaries with the data
                                    // from a single RR packet
                                    receiverData.updateReceiverState(rr.ReceiverReports, when, venueState);
                                        

                                    // this "refreshes" the host state (so that it won't expire)
                                    venueState.ReceiverData[ipEndpoint] = receiverData;
                                    break;
                                }

                            case (byte)Rtcp.PacketType.SDES:
                                {
                                    SdesPacket sdp = new SdesPacket(packet);                                   

                                    foreach(SdesReport report in sdp.Reports())
                                    {
                                        SenderData senderData = venueState.GetSenderState(report.SSRC);
                                        senderData.CName = report.SdesData.CName;
                                        senderData.Source = ipEndpoint;

                                        // this "refreshes" the host state (so that it won't expire)
                                        venueState.SenderData[report.SSRC] = senderData;

                                        ReceiverData receiverData = 
                                            venueState.GetReceiverDataWithoutCreating(ipEndpoint);

                                        if (receiverData != null)
                                            receiverData.CName = report.SdesData.CName;
                                    }
                                    break;
                                }

                            case (byte)Rtcp.PacketType.BYE:
                                {
                                    //BYE packets occur when capabilities stop.  Clean out sender data only for the
                                    //ssrc's affected.  We leave receiver reports alone for now.
                                    ByePacket byePacket = new ByePacket(packet);
                                    foreach (uint ssrc in byePacket.SSRCs) {
                                        venueState.SenderData.Remove(ssrc);
                                    }
                                    //Set a flag to cause the matrix for this venue to be rebuilt on the next request.
                                    venueState.ParticipantChange = true;
                                    continue;
                                }

                            case (byte)Rtcp.PacketType.APP:
                                {
                                    // ignored

                                    break;
                                }
                        }
                     }  // foreach packet...

                    // refresh the venue state
                     venueStateMap[venueName] = venueState;
                 }
                catch (Exception e)
                {
                    Console.Out.WriteLine("Exception : " + e.ToString());

                    writeEventLog("Exception in receive thread: " + e.ToString(), EventLogEntryType.Warning);
                }
            } // loop forever...
        }