public void ReceiveDesktopFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
// Decode frame
fDesktopViewer.ReceiveDesktopFrame(sender, ea);
// Display it on the desktop viewer
}
private void GDICommandReceived(object sender, RtpStream.FrameReceivedEventArgs ea)
{
// send the frame to the receiver
fChunkDecoder.ReceiveData(ea.Frame);
if (null != DataChangedEvent)
DataChangedEvent();
}
void ReceivedAudioEvent(object sender, RtpStream.FrameReceivedEventArgs ea)
{
int channels = ea.Frame.NextInt32();
int samplesPerSec = ea.Frame.NextInt32();
int bitsPerSample = ea.Frame.NextInt32();
int dataLength = ea.Frame.NextInt32();
byte[] data = (byte[])ea.Frame;
fSpeakers.Write(data, dataLength);
}
public virtual void ReceiveDesktopFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
// Find the attendee that matches the participant who sent the frame
if (!fAttendees.ContainsKey((int)ea.RtpStream.SSRC))
return;
ConferenceAttendee attendee;
attendee = fAttendees[(int)ea.RtpStream.SSRC];
if (null != attendee)
attendee.ReceiveDesktopFrame(sender, ea);
}
protected virtual void RtpStreamRemoved(object sender, RtpEvents.RtpStreamEventArgs ea)
{
if (ChannelType != ea.RtpStream.PayloadType)
return;
if (fUseFrameReceived)
{
ea.RtpStream.FrameReceived -= FrameReceived;
}
fIsReadyToSend = false;
fStream = null;
}
private void FrameReceived(object sender, RtpStream.FrameReceivedEventArgs ea)
{
ReceiveChunk(ea.Frame);
}
public RtpStreamEventArgs(RtpStream rtpStream)
{
RtpStream = rtpStream;
}
public InvalidPacketInFrameEventArgs(RtpStream rtpStream, string reason)
{
RtpStream = rtpStream;
Reason = reason;
}
public virtual void ReceiveAudioFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
fModel.ReceiveAudioFrame(sender, ea);
}
public void ReceiveAudioFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
fDeskSet.ReceiveVideoFrame(sender, ea);
}
private void CommandReceived(object sender, RtpStream.FrameReceivedEventArgs ea)
{
// send the frame to the receiver
fChunkDecoder.ReceiveData(ea);
}
public void ReceiveAudioFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
}
public bool ContainsStream(RtpStream stream)
{
return streamsAndIPs.ContainsKey(stream.SSRC);
//return (streamsAndIPs.GetStream(stream.SSRC) != null);
}
public IPStreamPair(IPAddress ip, RtpStream rtp)
{
senderIP = ip;
stream = rtp;
}
internal void RaiseRtpStreamTimeoutEvent(RtpStream stream)
{
rtpStreamTimeoutEvents++;
object[] args = {this, new RtpEvents.RtpStreamEventArgs(stream)};
EventThrower.QueueUserWorkItem(new RtpEvents.RaiseEvent(Events.RaiseRtpStreamTimeoutEvent), args);
}
/// <summary>
/// we have a new stream - start recording
/// </summary>
/// <param name="SSRC">what's arrived</param>
private void OnNewRtpStream(object sender, RtpEvents.RtpStreamEventArgs ea)
{
try {
RtpStream stream = ea.RtpStream;
eventLog.WriteEntry("OnNewRtpStream: " + stream.Properties.CName + " " +
stream.PayloadType.ToString(),
EventLogEntryType.Information, ArchiveServiceEventLog.ID.Information);
if (this.rtpSession != sender)
{
eventLog.WriteEntry("OnNewRtpStream: this.rtpSession and sender don't match.",
EventLogEntryType.Information, ArchiveServiceEventLog.ID.Information);
if (this.rtpSession == null)
{
eventLog.WriteEntry("OnNewRtpStream: this.rtpSession is null.",
EventLogEntryType.Information, ArchiveServiceEventLog.ID.Information);
}
if (sender == null)
{
eventLog.WriteEntry("OnNewRtpStream: sender is null.",
EventLogEntryType.Information, ArchiveServiceEventLog.ID.Information);
}
//return;
}
if (streams.ContainsKey(stream.SSRC))
{
eventLog.WriteEntry("OnNewRtpStream already in streams collection.",
EventLogEntryType.Information, ArchiveServiceEventLog.ID.Information);
return;
}
//eventLog.WriteEntry(string.Format(CultureInfo.CurrentCulture, " New stream found: {0}, {1}",
// stream.Properties.CName, stream.Properties.Name));
if (participants[stream.Properties.CName] != null)
{
ParticipantWrapper participant = (ParticipantWrapper)participants[stream.Properties.CName];
StreamRecorder sm = new StreamRecorder(participant.participantID, stream, perfCounter);
streams[stream.SSRC] = sm;
perfCounter.AddInstanceForCollection(sm);
// Make sure we don't stop recording now
if (this.stopTimer != null)
{
stopTimer.Dispose();
stopTimer = null;
}
eventLog.WriteEntry("OnNewRtpStream stream added complete.",
EventLogEntryType.Information, ArchiveServiceEventLog.ID.Information);
}
else
{
eventLog.WriteEntry(Strings.UnknownParticipantError + stream.Properties.CName,
EventLogEntryType.Information, ArchiveServiceEventLog.ID.Information);
}
}
catch (Exception e) {
eventLog.WriteEntry("OnNewRtpStream exception: " + e.ToString(),
EventLogEntryType.Warning, ArchiveServiceEventLog.ID.Warning);
}
}
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]);
}
}
public virtual void ReceiveFrame(RtpStream.FrameReceivedEventArgs ea)
{
ReceiveData(ea.Frame);
}
public void ReceiveVideoFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
fWebcamViewer.ReceiveDesktopFrame(sender, ea);
}
private async Task SetupTrackAsync(RtspMediaTrackInfo track, CancellationToken token)
{
RtspRequestMessage setupRequest;
RtspResponseMessage setupResponse;
int rtpChannelNumber;
int rtcpChannelNumber;
Socket rtpClient = null;
Socket rtcpClient = null;
if (_connectionParameters.RtpTransport == RtpTransportProtocol.UDP)
{
rtpClient = NetworkClientFactory.CreateUdpClient();
rtcpClient = NetworkClientFactory.CreateUdpClient();
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
rtpClient.Bind(endPoint);
int rtpPort = ((IPEndPoint)rtpClient.LocalEndPoint).Port;
endPoint = new IPEndPoint(IPAddress.Any, rtpPort + 1);
try
{
rtcpClient.Bind(endPoint);
}
catch (SocketException e) when(e.SocketErrorCode == SocketError.AddressAlreadyInUse)
{
endPoint = new IPEndPoint(IPAddress.Any, 0);
rtcpClient.Bind(endPoint);
}
int rtcpPort = ((IPEndPoint)rtcpClient.LocalEndPoint).Port;
setupRequest = _requestMessageFactory.CreateSetupUdpUnicastRequest(track.TrackName,
rtpPort, rtcpPort);
setupResponse = await _rtspTransportClient.EnsureExecuteRequest(setupRequest, token);
}
catch
{
rtpClient.Close();
rtcpClient.Close();
throw;
}
}
else
{
int channelCounter = _streamsMap.Count;
rtpChannelNumber = channelCounter;
rtcpChannelNumber = ++channelCounter;
setupRequest = _requestMessageFactory.CreateSetupTcpInterleavedRequest(track.TrackName,
rtpChannelNumber, rtcpChannelNumber);
setupResponse = await _rtspTransportClient.EnsureExecuteRequest(setupRequest, token);
}
string transportHeader = setupResponse.Headers[WellKnownHeaders.Transport];
if (string.IsNullOrEmpty(transportHeader))
{
throw new RtspBadResponseException("Transport header is not found");
}
string attributeName = _connectionParameters.RtpTransport == RtpTransportProtocol.UDP
? "server_port"
: "interleaved";
if (!ParseSeverPorts(transportHeader, attributeName, out rtpChannelNumber, out rtcpChannelNumber))
{
throw new RtspBadResponseException("Server ports are not found");
}
if (_connectionParameters.RtpTransport == RtpTransportProtocol.UDP)
{
IPEndPoint remoteEndPoint = (IPEndPoint)_rtspTransportClient.RemoteEndPoint;
rtpClient?.Connect(new IPEndPoint(remoteEndPoint.Address, rtpChannelNumber));
rtcpClient?.Connect(new IPEndPoint(remoteEndPoint.Address, rtcpChannelNumber));
var udpHolePunchingPacketSegment = new ArraySegment <byte>(Array.Empty <byte>());
await rtpClient.SendAsync(udpHolePunchingPacketSegment, SocketFlags.None);
await rtcpClient.SendAsync(udpHolePunchingPacketSegment, SocketFlags.None);
_udpClientsMap[rtpChannelNumber] = rtpClient;
_udpClientsMap[rtcpChannelNumber] = rtcpClient;
}
ParseSessionHeader(setupResponse.Headers[WellKnownHeaders.Session]);
IMediaPayloadParser mediaPayloadParser = MediaPayloadParser.CreateFrom(track.Codec);
IRtpSequenceAssembler rtpSequenceAssembler;
if (_connectionParameters.RtpTransport == RtpTransportProtocol.TCP)
{
rtpSequenceAssembler = null;
mediaPayloadParser.FrameGenerated = OnFrameGeneratedLockfree;
}
else
{
rtpSequenceAssembler = new RtpSequenceAssembler(Constants.UdpReceiveBufferSize, 8);
mediaPayloadParser.FrameGenerated = OnFrameGeneratedThreadSafe;
}
var rtpStream = new RtpStream(mediaPayloadParser, track.SamplesFrequency, rtpSequenceAssembler);
_streamsMap.Add(rtpChannelNumber, rtpStream);
var rtcpStream = new RtcpStream();
rtcpStream.SessionShutdown += (sender, args) => _serverCancellationTokenSource.Cancel();
_streamsMap.Add(rtcpChannelNumber, rtcpStream);
uint senderSyncSourceId = (uint)_random.Next();
var rtcpReportsProvider = new RtcpReceiverReportsProvider(rtpStream, rtcpStream, senderSyncSourceId);
_reportProvidersMap.Add(rtpChannelNumber, rtcpReportsProvider);
}
public static void FrameIncomplete(RtpStream rtpStream, int framesLost)
{
// Event logging and perf counting are done in called method
rtpStream.RaiseFrameOutOfSequenceEvent(framesLost, Strings.IncompleteFrameReceived);
}
public virtual void ReceiveData(RtpStream.FrameReceivedEventArgs ea)
{
BufferChunk aRecord = ea.Frame;
// First read out the record type
int recordType = aRecord.NextInt32();
switch (recordType)
{
case SpaceControlChannel.SC_MouseEvent:
{
Guid sourceID = CodecUtils.UnpackGuid(aRecord);
uint mouseID = aRecord.NextUInt32();
MouseEventType eventType = (MouseEventType)aRecord.NextInt32();
MouseButtons buttons = (MouseButtons)aRecord.NextInt32();
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int clicks = aRecord.NextInt32();
int delta = aRecord.NextInt32();
MouseEventArgs args = new MouseEventArgs(mouseID, eventType, buttons, clicks, x, y, delta, sourceID);
OnMouseActivity(this, args);
}
break;
case SpaceControlChannel.SC_KeyboardEvent:
break;
case SpaceControlChannel.SC_BitBlt:
{
// Get the X, Y
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
// Now create a pixbuff on the specified size
PixelBuffer pixBuff = new PixelBuffer(width, height);
int dataSize = aRecord.NextInt32();
// Copy the received data into it right pixel data pointer
aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);
// And finally, call the BitBlt function
BitBlt(x,y,pixBuff);
}
break;
case SpaceControlChannel.SC_AlphaBlend:
{
// Get the X, Y
int x = aRecord.NextInt32();
int y = aRecord.NextInt32();
int width = aRecord.NextInt32();
int height = aRecord.NextInt32();
int srcX = aRecord.NextInt32();
int srcY = aRecord.NextInt32();
int srcWidth = aRecord.NextInt32();
int srcHeight = aRecord.NextInt32();
byte alpha = aRecord.NextByte();
// Now create a pixbuff on the specified size
int buffWidth = aRecord.NextInt32();
int buffHeight = aRecord.NextInt32();
PixelBuffer pixBuff = new PixelBuffer(buffWidth, buffHeight);
int dataSize = aRecord.NextInt32();
// Copy the received data into it right pixel data pointer
aRecord.CopyTo(pixBuff.Pixels.Data, dataSize);
// And finally, call the BitBlt function
AlphaBlend(x,y,width,height, pixBuff,srcX,srcY, srcWidth,srcHeight,alpha);
}
break;
case SpaceControlChannel.SC_ScaleBitmap:
break;
case SpaceControlChannel.SC_None:
default:
break;
}
}
public void ReceiveDesktopFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
fDeskSet.ReceiveDesktopFrame(sender, ea);
}
private void FrameReceived(object sender, RtpStream.FrameReceivedEventArgs ea)
{
BufferChunk frame = ea.Frame;
if(frame.Length != data.Length)
{
throw new TestCaseException(string.Format("Lengths don't match! lengthSent: {0}, lengthRecv'd: {1}",
data.Length, frame.Length));
}
for(int i = 0; i < frame.Length; i++)
{
if(frame[i] != data[i])
{
throw new TestCaseException(string.Format("Bytes don't match! Index:{0}, byteSent: {1} + byteRecv'd: {2}",
i.ToString(), data[i].ToString(), frame[i].ToString()));
}
}
are.Set();
}
private void FrameReceived(object sender, RtpStream.FrameReceivedEventArgs ea)
{
if (null != FrameReceivedEvent)
FrameReceivedEvent(sender, ea);
}
private async Task SetupTrackAsync(RtspMediaTrackInfo track, CancellationToken token)
{
RtspRequestMessage setupRequest;
RtspResponseMessage setupResponse;
int rtpChannelNumber;
int rtcpChannelNumber;
Socket rtpClient = null;
Socket rtcpClient = null;
if (_connectionParameters.RtpTransport == RtpTransportProtocol.UDP)
{
rtpClient = NetworkClientFactory.CreateUdpClient();
rtcpClient = NetworkClientFactory.CreateUdpClient();
try
{
IPEndPoint endPoint = new IPEndPoint(IPAddress.Any, 0);
rtpClient.Bind(endPoint);
int rtpPort = ((IPEndPoint)rtpClient.LocalEndPoint).Port;
endPoint = new IPEndPoint(IPAddress.Any, rtpPort + 1);
try
{
rtcpClient.Bind(endPoint);
}
catch (SocketException e) when(e.SocketErrorCode == SocketError.AddressAlreadyInUse)
{
endPoint = new IPEndPoint(IPAddress.Any, 0);
rtcpClient.Bind(endPoint);
}
int rtcpPort = ((IPEndPoint)rtcpClient.LocalEndPoint).Port;
setupRequest = _requestMessageFactory.CreateSetupUdpUnicastRequest(track.TrackName,
rtpPort, rtcpPort);
setupResponse = await _rtspTransportClient.EnsureExecuteRequest(setupRequest, token);
}
catch
{
rtpClient.Close();
rtcpClient.Close();
throw;
}
}
else
{
int channelCounter = _streamsMap.Count;
rtpChannelNumber = channelCounter;
rtcpChannelNumber = ++channelCounter;
setupRequest = _requestMessageFactory.CreateSetupTcpInterleavedRequest(track.TrackName,
rtpChannelNumber, rtcpChannelNumber);
setupResponse = await _rtspTransportClient.EnsureExecuteRequest(setupRequest, token);
}
string transportHeader = setupResponse.Headers[WellKnownHeaders.Transport];
if (string.IsNullOrEmpty(transportHeader))
{
throw new RtspBadResponseException("Transport header is not found");
}
string portsAttributeName = _connectionParameters.RtpTransport == RtpTransportProtocol.UDP
? "server_port"
: "interleaved";
string[] transportAttributes = transportHeader.Split(TransportAttributesSeparator, StringSplitOptions.RemoveEmptyEntries);
string portsAttribute = transportAttributes.FirstOrDefault(a => a.StartsWith(portsAttributeName, StringComparison.InvariantCultureIgnoreCase));
if (portsAttribute == null || !TryParseSeverPorts(portsAttribute, out rtpChannelNumber, out rtcpChannelNumber))
{
throw new RtspBadResponseException("Server ports are not found");
}
if (_connectionParameters.RtpTransport == RtpTransportProtocol.UDP)
{
string sourceAttribute = transportAttributes.FirstOrDefault(a => a.StartsWith("source", StringComparison.InvariantCultureIgnoreCase));
int equalSignIndex;
IPAddress sourceAddress;
if (sourceAttribute != null && (equalSignIndex = sourceAttribute.IndexOf("=", StringComparison.CurrentCultureIgnoreCase)) != -1)
{
sourceAddress = IPAddress.Parse(sourceAttribute.Substring(++equalSignIndex).Trim());
}
else
{
sourceAddress = ((IPEndPoint)_rtspTransportClient.RemoteEndPoint).Address;
}
Debug.Assert(rtpClient != null, nameof(rtpClient) + " != null");
rtpClient.Connect(new IPEndPoint(sourceAddress, rtpChannelNumber));
Debug.Assert(rtcpClient != null, nameof(rtcpClient) + " != null");
rtcpClient.Connect(new IPEndPoint(sourceAddress, rtcpChannelNumber));
var udpHolePunchingPacketSegment = new ArraySegment <byte>(Array.Empty <byte>());
await rtpClient.SendAsync(udpHolePunchingPacketSegment, SocketFlags.None);
await rtcpClient.SendAsync(udpHolePunchingPacketSegment, SocketFlags.None);
_udpClientsMap[rtpChannelNumber] = rtpClient;
_udpClientsMap[rtcpChannelNumber] = rtcpClient;
}
ParseSessionHeader(setupResponse.Headers[WellKnownHeaders.Session]);
IMediaPayloadParser mediaPayloadParser = MediaPayloadParser.CreateFrom(track.Codec);
IRtpSequenceAssembler rtpSequenceAssembler;
if (_connectionParameters.RtpTransport == RtpTransportProtocol.TCP)
{
rtpSequenceAssembler = null;
mediaPayloadParser.FrameGenerated = OnFrameGeneratedLockfree;
}
else
{
rtpSequenceAssembler = new RtpSequenceAssembler(Constants.UdpReceiveBufferSize, 256);
mediaPayloadParser.FrameGenerated = OnFrameGeneratedThreadSafe;
}
var rtpStream = new RtpStream(mediaPayloadParser, track.SamplesFrequency, rtpSequenceAssembler);
_streamsMap.Add(rtpChannelNumber, rtpStream);
var rtcpStream = new RtcpStream();
rtcpStream.SessionShutdown += (sender, args) => _serverCancellationTokenSource.Cancel();
_streamsMap.Add(rtcpChannelNumber, rtcpStream);
uint senderSyncSourceId = (uint)_random.Next();
var rtcpReportsProvider = new RtcpReceiverReportsProvider(rtpStream, rtcpStream, senderSyncSourceId);
_reportProvidersMap.Add(rtpChannelNumber, rtcpReportsProvider);
}
public FrameOutOfSequenceEventArgs(RtpStream rtpStream, int lostFrames, string message)
{
RtpStream = rtpStream;
LostFrames = lostFrames;
Message = message;
}
// CF1, CF3
private void RtpStreamAdded(object sender, RtpEvents.RtpStreamEventArgs ea)
{
rtpStream = ea.RtpStream;
}
public PacketOutOfSequenceEventArgs ( RtpStream rtpStream, int lostPackets, string message )
{
RtpStream = rtpStream;
LostPackets = lostPackets;
Message = message;
}
protected virtual void FrameReceived(object sender, RtpStream.FrameReceivedEventArgs ea)
{
//ShowMessage(string.Format(CultureInfo.CurrentCulture, "{0}: {1}", ea.RtpStream.Properties.Name,
// (string)ea.Frame));
}
public void ReceiveDesktopFrame(object sender, RtpStream.FrameReceivedEventArgs ea)
{
// WAA
//fChunkDecoder.ReceiveChunk(ea.Frame);
}
public ListenerThreadData(RtpStream stream, Thread thread)
{
Stream = stream;
ListenerThread = thread;
aborted = false;
}
public ListeningMethodArguements(ListeningThreadMethod threadMethod, RtpStream rtpStream)
{
this.threadMethod = threadMethod;
this.rtpStream = rtpStream;
}
protected virtual void RtpStreamAdded(object sender, RtpEvents.RtpStreamEventArgs ea)
{
if (ChannelType != ea.RtpStream.PayloadType)
return;
if (fUseFrameReceived)
{
ea.RtpStream.FrameReceived += FrameReceived;
}
fIsReadyToSend = true;
fStream = ea.RtpStream;
}
