Beispiel #1
0
        public void Process_TwoTestPacketsWithLargeSequenceDifference_ResetStateShouldBeCalled()
        {
            var testPacketBytes1       = new byte[] { 0x80, 0x60, 0x00, 0x00, 0x89, 0xBB, 0x82, 0xED, 0x42, 0x60, 0xD6, 0x86 };
            var testPacketBytes2       = new byte[] { 0x80, 0x60, 0x51, 0x50, 0x89, 0xBB, 0x82, 0xED, 0x42, 0x60, 0xD6, 0x86 };
            var mediaPayloadParserMock = new Mock <IMediaPayloadParser>();

            var rtpStream = new RtpStream(mediaPayloadParserMock.Object, 1);

            rtpStream.Process(new ArraySegment <byte>(testPacketBytes1));
            rtpStream.Process(new ArraySegment <byte>(testPacketBytes2));

            mediaPayloadParserMock.Verify(x => x.ResetState());
        }
        private async Task ReceiveRtpFromUdpAsync(Socket client, RtpStream rtpStream,
                                                  RtcpReceiverReportsProvider reportsProvider,
                                                  CancellationToken token)
        {
            var readBuffer    = new byte[Constants.UdpReceiveBufferSize];
            var bufferSegment = new ArraySegment <byte>(readBuffer);

            int nextRtcpReportInterval  = GetNextRtcpReportIntervalMs();
            int lastTimeRtcpReportsSent = Environment.TickCount;
            var bufferStream            = new MemoryStream();

            while (!token.IsCancellationRequested)
            {
                int read = await client.ReceiveAsync(bufferSegment, SocketFlags.None);

                var payloadSegment = new ArraySegment <byte>(readBuffer, 0, read);
                rtpStream.Process(payloadSegment);

                int ticksNow = Environment.TickCount;
                if (!TimeUtils.IsTimeOver(ticksNow, lastTimeRtcpReportsSent, nextRtcpReportInterval))
                {
                    continue;
                }

                lastTimeRtcpReportsSent = ticksNow;
                nextRtcpReportInterval  = GetNextRtcpReportIntervalMs();

                IEnumerable <RtcpPacket> packets     = reportsProvider.GetReportPackets();
                ArraySegment <byte>      byteSegment = SerializeRtcpPackets(packets, bufferStream);

                await client.SendAsync(byteSegment, SocketFlags.None);
            }
        }
Beispiel #3
0
        public void Process_TestPacket_ParseShouldBeCalled()
        {
            var testPacketBytes = new byte[]
            { 0x80, 0x60, 0x51, 0x50, 0x89, 0xBB, 0x82, 0xED, 0x42, 0x60, 0xD6, 0x86, 0x01 };
            var mediaPayloadParserMock = new Mock <IMediaPayloadParser>();

            var rtpStream = new RtpStream(mediaPayloadParserMock.Object, 1);

            rtpStream.Process(new ArraySegment <byte>(testPacketBytes));

            mediaPayloadParserMock.Verify(x => x.Parse(It.IsAny <TimeSpan>(),
                                                       It.Is <ArraySegment <byte> >(p => p.Count == 1),
                                                       It.Is <bool>(m => m == false)));
        }
Beispiel #4
0
        public void Process_TestPacket_FieldsUpdated()
        {
            var testPacketBytes        = new byte[] { 0x80, 0x60, 0x51, 0x50, 0x89, 0xBB, 0x82, 0xED, 0x42, 0x60, 0xD6, 0x86 };
            var mediaPayloadParserMock = new Mock <IMediaPayloadParser>();

            var rtpStream = new RtpStream(mediaPayloadParserMock.Object, 1);

            rtpStream.Process(new ArraySegment <byte>(testPacketBytes));

            Assert.AreEqual(0x4260D686u, rtpStream.SyncSourceId);
            Assert.AreEqual(20816, rtpStream.HighestSequenceNumberReceived);
            Assert.AreEqual(1, rtpStream.PacketsReceivedSinceLastReset);
            Assert.AreEqual(0, rtpStream.PacketsLostSinceLastReset);
            Assert.AreEqual(0u, rtpStream.CumulativePacketLost);
            Assert.AreEqual(0, rtpStream.SequenceCycles);
        }
Beispiel #5
0
        private async Task ReceiveRtpFromUdpAsync(Socket client, Socket clientRtcp, RtpStream rtpStream,
                                                  RtcpReceiverReportsProvider reportsProvider,
                                                  CancellationToken token)
        {
            var readBuffer    = new byte[Constants.UdpReceiveBufferSize];
            var bufferSegment = new ArraySegment <byte>(readBuffer);

            int nextRtcpReportInterval  = GetNextRtcpReportIntervalMs();
            int lastTimeRtcpReportsSent = Environment.TickCount;
            var bufferStream            = new MemoryStream();

            IEnumerable <RtcpPacket> packets;
            ArraySegment <byte>      byteSegment;

            try
            {
                while (!token.IsCancellationRequested)
                {
                    int read = await client.ReceiveAsync(bufferSegment, SocketFlags.None).WithCancellation(token);

                    var payloadSegment = new ArraySegment <byte>(readBuffer, 0, read);
                    rtpStream.Process(payloadSegment);

                    int ticksNow = Environment.TickCount;
                    if (!TimeUtils.IsTimeOver(ticksNow, lastTimeRtcpReportsSent, nextRtcpReportInterval))
                    {
                        continue;
                    }

                    lastTimeRtcpReportsSent = ticksNow;
                    nextRtcpReportInterval  = GetNextRtcpReportIntervalMs();

                    packets     = reportsProvider.GetReportSdesPackets();
                    byteSegment = SerializeRtcpPackets(packets, bufferStream);

                    if (_connectionParameters.RtpTransport == RtpTransportProtocol.UDP)
                    {
                        await clientRtcp.SendAsync(byteSegment, SocketFlags.None).WithCancellation(token);
                    }
                    else if (_connectionParameters.RtpTransport == RtpTransportProtocol.MULTICAST)
                    {
                        await clientRtcp.SendToAsync(byteSegment, SocketFlags.None, _udpJoinedGroupsMap[clientRtcp]).WithCancellation(token);
                    }
                }
            }
            catch (OperationCanceledException)
            {
                if (!token.IsCancellationRequested)
                {
                    throw;
                }
            }

            packets     = reportsProvider.GetReportByePackets();
            byteSegment = SerializeRtcpPackets(packets, bufferStream);

            if (_connectionParameters.RtpTransport == RtpTransportProtocol.UDP)
            {
                await clientRtcp.SendAsync(byteSegment, SocketFlags.None);
            }
            else if (_connectionParameters.RtpTransport == RtpTransportProtocol.MULTICAST)
            {
                await clientRtcp.SendToAsync(byteSegment, SocketFlags.None, _udpJoinedGroupsMap[clientRtcp]);
            }
        }