Beispiel #1
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...
        }