static void Main(string[] args) { RtpParticipant part = new RtpParticipant("*****@*****.**", "SENDER"); RtpSession session = new RtpSession(ip, part, true, true); session.PacketTransform = new EncryptionTransform("You are a big freak!"); //session.PacketTransform = new XorTransform(); RtpSender sender = session.CreateRtpSender("My sender", PayloadType.Test, null); Stream fs = File.OpenRead("data.txt"); int length = (int)fs.Length; Console.Out.WriteLine("Opening file of length: " + length); byte[] buffer = new byte[length]; int bytesRead = 0; while (bytesRead < length) { bytesRead += fs.Read(buffer, bytesRead, Math.Min(16384, (length - bytesRead))); } for (int i = 0; i < 5; i++) { Console.Out.WriteLine("Sending buffer to address: " + ip); sender.Send(buffer); Thread.Sleep(1000); } }
public RTPReceiveConnection(IPEndPoint ip, NetworkArchiver na) { RtpEvents.RtpStreamAdded += new MSR.LST.Net.Rtp.RtpEvents.RtpStreamAddedEventHandler(this.handleRtpStreamAdded); RtpEvents.RtpStreamRemoved += new MSR.LST.Net.Rtp.RtpEvents.RtpStreamRemovedEventHandler(this.handleRtpStreamRemoved); this.m_Participant = new RtpParticipant("Recorder", "Recorder"); this.m_Session = new RtpSession(ip, this.m_Participant, true, true); this.m_archiver = na; }
public RTPMessageSender(IPEndPoint ep, PresenterModel model, ClassroomModel classroom) { this.m_Model = model; this.m_Classroom = classroom; this.m_RtpLocalParticipant = new RtpLocalParticipant(this.m_Model.Participant); using(Synchronizer.Lock(this)) { // Register the stream event listeners first, since otherwise there would be a chance // that streams could be added between creating the RtpSession (which connects immediately). this.m_ParticipantManager = new ParticipantManager(this); this.m_RtpSession = new RtpSession(ep, this.m_RtpLocalParticipant, true, true); // TODO: Choose a meaningful value for the RtpSender name. ushort fec; short interpacketdelay; using (Synchronizer.Lock(model.SyncRoot)) { using (Synchronizer.Lock(model.ViewerState.SyncRoot)) { fec = (ushort)model.ViewerState.ForwardErrorCorrection; interpacketdelay = (short)model.ViewerState.InterPacketDelay; } } if( fec == 0 ) this.m_RtpSender = this.m_RtpSession.CreateRtpSender( "Classroom Presenter", PayloadType.dynamicPresentation, null ); else this.m_RtpSender = this.m_RtpSession.CreateRtpSenderFec( "Classroom Presenter", PayloadType.dynamicPresentation, null, 0, fec ); this.m_RtpSender.DelayBetweenPackets = interpacketdelay; // Initialize the message chunking utilities. this.m_Encoder = new Chunk.ChunkEncoder(); // TODO: Make the buffer size dynamic, ie., grow if we send a single very large message. // Make the buffer store up to 5MB worth of data. this.m_FrameBuffer = new FrameBuffer(5 * 1024 * 1024 / this.m_Encoder.MaximumChunkSize); // Create the NackManager which is responsible for sending NACKs on behalf of // our set of RTPMessageReceivers. this.m_NackManager = new RTPNackManager(this, this.m_Classroom); } // Create network services outside of the "lock(this)" so they can lock their own objects // without worrying about locking order. // Create the PresenterNetworkService which will watch for changes to the model and send messages. this.m_PresenterNetworkService = new PresenterNetworkService(this, this.m_Model); // Create the StudentSubmissionsNetworkService which will watch for requests to submit and send messages. this.m_StudentSubmissionNetworkService = new StudentSubmissionNetworkService(this, this.m_Model); // Create the SynchronizationNetworkService which will watch for all synchronization messages. this.m_SynchronizationNetworkService = new SynchronizationNetworkService( this, this.m_Model ); // Create the ScriptingNetworkService which will watch for all scripting messages. this.m_ScriptingNetworkService = new ScriptingNetworkService( this, this.m_Model ); // Create the BeaconService which will broadcast periodic information about the presentation. this.m_BeaconService = new Beacons.DefaultBeaconService(this, this.m_Model); }
public SimpleTest() { // Create participant RtpParticipant rtpParticipant = null; //rtpParticipant.SetTool(true); // Create session with Participant and Rtp data rtpSession = new RtpSession(new IPEndPoint(IPAddress.Parse(addr), rtpPort), rtpParticipant, false, true); }
static void Main(string[] args) { RtpEvents.RtpStreamAdded += new RtpEvents.RtpStreamAddedEventHandler(OnNewRtpStream); RtpParticipant part = new RtpParticipant("*****@*****.**", "Receiver"); session = new RtpSession(ip, part, true, true); //session.PacketTransform = new XorTransform(); session.PacketTransform = new EncryptionTransform("You are a big freak!"); // make sure this thing doesn't terminate while (true) { Thread.Sleep(10000); } }
/// <summary> /// get details of the stream...raw data and start tiume etc /// set up the stream senders associated with us. we have n, one active and the rest acting as buffers /// </summary> public StreamPlayer( RtpSession session, int newStreamID, ConferencePlayerPC cppc) { int maxFrameSize, maxFrameCount, maxBufferSize; // This occasionally throws due to bad data. Let ConferencePlayer handle it. DBHelper.GetStreamStatistics( newStreamID, out this.firstStreamTicks, out maxFrameSize, out maxFrameCount, out maxBufferSize); streamID = newStreamID; totalFramesSent = 0; totalBytesSent = 0; totalLateness = 0; buffers = new BufferPlayer[Constants.BuffersPerStream]; perfCounter = cppc; string payload; DBHelper.GetStreamAndParticipantDetails( streamID, out name, out payload, out cname, out privExtns ); streamPayload = (PayloadType)Enum.Parse( typeof(PayloadType), payload, true ); // for delayed buffers (late joiners), we create the rtpSender later this.rtpSession = session; Trace.WriteLine("Playing back stream: "+streamID+"; payload: "+streamPayload+"; name: "+ (cname + " : " +name)); // buffer n buffers worth of data long startingTick = this.firstStreamTicks; for ( int i = 0; i < buffers.Length; i++) { buffers[i] = new BufferPlayer( streamID, maxFrameSize, maxFrameCount, maxBufferSize); buffers[i].Populate( startingTick ); startingTick = buffers[i].LastTick + 1; perfCounter.AddInstanceForCollection(buffers[i]); } // first stream is initially active activeBufferIndex = 0; activeBuffer = buffers[activeBufferIndex]; }
private void InitializeNetwork() { RtpEvents.ReceiverReport += new RtpEvents.ReceiverReportEventHandler(RtpReceiverReport); RtpEvents.DuplicateCNameDetected += new RtpEvents.DuplicateCNameDetectedEventHandler(DuplicateCNameDetected); // Create participant rtpParticipant = new RtpParticipant(cName, name); rtpParticipant.SetTool(true); // Create session with Participant and Rtp data rtpSession = new RtpSession(new IPEndPoint(IPAddress.Parse(ipAddress), port), rtpParticipant, true, true); // Create RtpSender rtpSender = rtpSession.CreateRtpSender(HostName, PayloadType.PipecleanerSignal, null, null); }
public void StopPlaying() { if( playing == false ) return; if( avPlayer != null ) { avPlayer.Stop(); avPlayer = null; } if( otherPlayer != null ) { otherPlayer.Stop(); otherPlayer = null; } if( this.perfCounter != null ) { perfCounter.Dispose(); } lock(this) { if( rtpSession != null ) { rtpSession.Dispose(); rtpSession = null; } playing = false; } }
public void Play( IPEndPoint venue, int[] streams, bool receiveData ) { if( this.playing ) throw new InvalidOperationException("ConferencePlayer::Play called when the player is already playing."); if( streams == null ) throw new ArgumentNullException("streams cannot be null"); venueIPE = venue; // Create an RtpSession RtpParticipant me = new RtpParticipant(Constants.PersistenceCName, Constants.PersistenceName + " (Playing)"); rtpSession = new RtpSession(venue, me, true, receiveData); // Hook the static stream-ended event StreamPlayer.EndOfStreamReached += new EventHandler(EndOfStreamReached); // Create a new perf counter for this ConferencePlayer instance this.perfCounter = new ConferencePlayerPC(venue.ToString()); // Keep track of the streamPlayers ArrayList avStreams = new ArrayList(); ArrayList otherStreams = new ArrayList(); // Find the first stored ticks of all the streams while creating them... this.firstStoredTick = long.MaxValue; // Create all of our StreamPlayers (one per stream...) for ( int i = 0; i < streams.Length; i++) { StreamPlayer newStream = null; try { newStream = new StreamPlayer(rtpSession, streams[i], perfCounter); } catch( Exception ex ) { eventLog.WriteEntry(String.Format("Stream with bad data reached. Continuing playback of all other streams." + " Stream ID: {0}. Exception: \n {1}", streams[i], ex.ToString()), EventLogEntryType.Warning, ArchiveServiceEventLog.ID.BadStreamInDB); } if( newStream != null ) { perfCounter.AddInstanceForCollection( newStream ); if( newStream.FirstStreamsTicks < this.firstStoredTick ) this.firstStoredTick = newStream.FirstStreamsTicks; // Add the new StreamPlayer to the right collection // Pri3: Consider other methods here. Maybe a smarter detection of large frame sizes, // or initializing the stream so it has enough packets ahead of time? if( newStream.Payload == PayloadType.dynamicAudio || newStream.Payload == PayloadType.dynamicVideo ) avStreams.Add(newStream); else // RTDocs stream or other large-payload stream, most likely otherStreams.Add(newStream); } } // Start the StreamsGroupPlayers // Pri2: Change this to be compatable with use of the "playback speed" feature. long startTime = DateTime.Now.Ticks + 1500*Constants.TicksPerMs; // we'll start in 1.5 seconds (for init time) // Create the StreamsGroupPlayer(s) avPlayer = new StreamsGroupPlayer(avStreams, this.firstStoredTick, startTime); otherPlayer = new StreamsGroupPlayer(otherStreams, this.firstStoredTick, startTime); this.playing = true; }
/// <summary> /// Join the Venue and start participating. AutoSend default devices if AutoSend == true /// </summary> public static void JoinVenue(IVenue venue) { lock(venue) { if (Conference.ActiveVenue != null) { throw new InvalidOperationException("Cannot join a venue when already joined to a venue."); } if (venue.VenueData.VenueType == VenueType.Invalid) { throw new ArgumentException("Can not join a venue that is of type Invalid"); } // (pfb) Why are we checking this here? When would it happen? if (rtpSession == null) { // Do this first, or else the locks in the eventHandlers will throw, due to null argument Conference.activeVenue = venue; HookRtpEvents(); #region Start the RtpSession try { // Pri3: Add casting of a Participant to an RtpParticipant Participant p = Conference.LocalParticipant; RtpParticipant rp = new RtpParticipant(p.Identifier, p.Name); rp.Email = p.Email; rp.Location = Conference.Location; rp.Phone = p.Phone; if (Conference.ReflectorEnabled && MSR.LST.Net.Utility.IsMulticast(venue.EndPoint)) { IPEndPoint refEP; IPAddress reflectorIP; int unicastPort; // Resolve the reflector address try { reflectorIP = System.Net.Dns.GetHostEntry( Conference.ReflectorAddress).AddressList[0]; } catch(Exception e) { throw new Exception("Reflector address not found - " + Conference.ReflectorAddress, e); } // Send a join request to the reflector and receive the RTP unicast port back regClient = new RegistrarClient(reflectorIP, Conference.ReflectorJoinPort); try { unicastPort = regClient.join(venue.EndPoint.Address, venue.EndPoint.Port); } catch(Exception e) { throw new Exception("Reflector join request failed", e); } refEP = new IPEndPoint(reflectorIP, unicastPort); rtpSession = new RtpSession(venue.EndPoint, rp, true, true, refEP); } else { rtpSession = new RtpSession(venue.EndPoint, rp, true, true); } } catch (System.Net.Sockets.SocketException se) { eventLog.WriteEntry(se.ToString(), EventLogEntryType.Error, 99); LeaveVenue(); if (se.ErrorCode == 10013) { throw new Exception("A security error occurred connecting to the network " + "(WSAEACCES). Common causes of this error are; no network " + "connection can be found, a change to the .NET Framework or " + "Winsock without a reboot, or recently disconnecting from a " + "VPN session which leaves Winsock in an indeterminate state. " + "Check your network connectivity or reboot your computer and try " + "again."); } else { throw; } } catch (Exception e) { eventLog.WriteEntry(e.ToString(), EventLogEntryType.Error, 99); LeaveVenue(); throw; } #endregion } } }
/// <summary> /// Leave the Venue and do all the cleanup work. /// </summary> public static void LeaveVenue() { if( Conference.ActiveVenue == null ) throw new InvalidOperationException("Cannot exit a venue when not in a venue!"); lock(Conference.ActiveVenue) { // So nothing new is created from the network UnhookRtpEvents(); // Clean up participants + owned capabilities foreach(Participant p in new ArrayList(participants.Values)) { // A dependency on the local participant dictates that we should always have the local participant // in the venue. if( p != Conference.localParticipant ) RemoveParticipant(p); } Debug.Assert(participants.Count == 1); // Dispose remaining capabilities (channels) foreach(ICapability ic in new ArrayList(capabilities.Values)) { DisposeCapability(ic); } Debug.Assert(capabilities.Count == 0); Debug.Assert(capabilityViewers.Count == 0); Debug.Assert(capabilitySenders.Count == 0); // Clear collection of form positions capabilityForms.Clear(); // Leave the network if (rtpSession != null) { rtpSession.Dispose(); rtpSession = null; } // Send a leave request to the reflector if the reflector was enabled when joining // the venue. Do this after leaving the Session, so that BYE packets have been sent // through reflector if (Conference.ReflectorEnabled && regClient != null) { regClient.leave(); } Conference.activeVenue = null; } }
/// <summary> /// Stops recording the current conference /// </summary> public void StopRecording() { if( stopTimer != null ) { stopTimer.Dispose(); stopTimer = null; } if( this.perfCounter != null ) { this.perfCounter.Dispose(); } if( this.recording ) { perfCounter.Dispose(); // Stop all the streams foreach ( StreamRecorder sm in streams.Values) { sm.StopListening(); } streams = null; participants = null; // Stop the rtpSession RtpEvents.RtpParticipantAdded -= new RtpEvents.RtpParticipantAddedEventHandler(this.OnNewRtpParticipant); RtpEvents.RtpStreamAdded -= new RtpEvents.RtpStreamAddedEventHandler(this.OnNewRtpStream); RtpEvents.RtpStreamRemoved -= new RtpEvents.RtpStreamRemovedEventHandler(this.OnRtpStreamRemoved); if( rtpSession != null ) { rtpSession.Dispose(); rtpSession = null; } DBHelper.RecordConferenceEndTime( conferenceID, System.DateTime.Now); this.recording = false; } }
/// <summary> /// Starts recording a conference. Sets up the conference data and then records all streams received until told to stop. /// </summary> public void RecordConference( string conferenceDescription, string venueIdentifier, IPEndPoint venue ) { if( conferenceDescription.Length >= Constants.MaxDBStringSize || venueIdentifier.Length >= Constants.MaxDBStringSize ) throw new ArgumentException("String longer than accepted by database."); recording = true; venueIPE = venue; streams = new Hashtable(Constants.InitialStreams); participants = new Hashtable(); conferenceID = DBHelper.CreateConference( conferenceDescription, venueIdentifier, DateTime.Now); // Store info about this conference to the instance, for debugging reference (mostly) this.conferenceDescription = conferenceDescription; this.venueIdentifier = venueIdentifier; this.venue = venue; // Create our performance counter perfCounter = new ConferenceRecorderPC( venueIdentifier + " : " + conferenceDescription ); // Set up RTCP properties RtpEvents.RtpParticipantAdded += new MSR.LST.Net.Rtp.RtpEvents.RtpParticipantAddedEventHandler(this.OnNewRtpParticipant); RtpEvents.RtpStreamAdded += new MSR.LST.Net.Rtp.RtpEvents.RtpStreamAddedEventHandler(this.OnNewRtpStream); RtpEvents.RtpStreamRemoved += new MSR.LST.Net.Rtp.RtpEvents.RtpStreamRemovedEventHandler(this.OnRtpStreamRemoved); // Start listening RtpParticipant rtpMe = new RtpParticipant(Constants.PersistenceCName, Constants.PersistenceName + " (RECORDING)"); rtpSession = new RtpSession(venue, rtpMe, true, true); }
public void JoinRTPSession(bool receive) { if (receive) { RegisterRtpUserEvents(); RegisterRtpStreamEvents(); } rtpSession = new RtpSession(network.GetChannel(channel), new RtpParticipant(Environment.MachineName, Environment.MachineName), true, receive); rtpSender = rtpSession.CreateRtpSender("VOIP Listener", PayloadType.dynamicAudio, null); }
/// <summary> /// Leave the Venue and do all the cleanup work. /// </summary> public static void LeaveVenue() { if( Conference.ActiveVenue == null ) throw new InvalidOperationException(Strings.CannotExitNotInVenue); lock(Conference.ActiveVenue) { StopDiagnosticMonitor(); // So nothing new is created from the network UnhookRtpEvents(); // Clean up participants + owned capabilities foreach(Participant p in new ArrayList(participants.Values)) { // A dependency on the local participant dictates that we should always have the local participant // in the venue. if( p != Conference.localParticipant ) RemoveParticipant(p); } Debug.Assert(participants.Count == 1); // Dispose remaining capabilities (channels) foreach(ICapability ic in new ArrayList(capabilities.Values)) { DisposeCapability(ic); } Debug.Assert(capabilities.Count == 0); Debug.Assert(capabilityViewers.Count == 0); Debug.Assert(capabilitySenders.Count == 0); // Clear collection of form positions capabilityForms.Clear(); // Leave the network if (rtpSession != null) { rtpSession.Dispose(); rtpSession = null; } // andrew: termination of reflector sessions is now done in UdpListner. This should happen // as a side-effect of disposing the RTP session. Conference.activeVenue = null; } originalWindowPositions.Clear(); Utilities.SaveWindowPersistenceData(windowPersistenceData); }
private void LeaveRtpSession() { if(rtpSession != null) { // Clean up all outstanding objects owned by the RtpSession rtpSession.Dispose(); rtpSession = null; rtpSender = null; } }
public RTPSendConnection(IPEndPoint ipe) { this.m_Participant = new RtpParticipant(Guid.NewGuid().ToString(), "Classroom Playback"); this.m_Session = new RtpSession(ipe, this.m_Participant, true, false); this.m_Sender = this.m_Session.CreateRtpSenderFec("Classroom Presenter", PayloadType.dynamicPresentation, null, 0, 100); this.m_Queue = new SendingQueue(this); }
// CF2 Create participant, join session // CF3 Retrieve RtpSender private void JoinRtpSession(string name) { rtpSession = new RtpSession(ep, new RtpParticipant(name, name), true, true); rtpSender = rtpSession.CreateRtpSenderFec(name, PayloadType.Chat, null, 0, 200); }
internal static RtpSender CreateInstance(RtpSession rtpSession, string name, PayloadType pt, Hashtable priExns) { return CreateInstance(rtpSession, name, pt, priExns, 0); }
public RtpListener(IPEndPoint nextHopEP, IPEndPoint groupEP, RtpSession rtpSession) { this.rtpSession = rtpSession; this.nextHopEP = nextHopEP; this.groupEP = groupEP; returnBufferHandler = new ReturnBufferHandler(ReturnBuffer); getBufferHandler = new GetBufferHandler(GetBuffer); InitializeBufferPool(); InitializePerformanceCounters(); InitializeNetwork(); InitializeThreads(); }
public RtpListener(IPEndPoint nextHopEP, RtpSession rtpSession) : this(nextHopEP, nextHopEP, rtpSession) { }
private void DisposeRtpSession() { if (rtpSession != null) { rtpSession.Dispose(); rtpSession = null; rtpSender = null; } }
private void JoinRtpSession() { RtpParticipant participant = new RtpParticipant("Video" + pb1.Handle.ToInt32(), "Video"); rtpSession = new RtpSession(ep, participant, true, true); }
public RtpListener(RtpSession rtpSession) { this.rtpSession = rtpSession; returnBufferHandler = new ReturnBufferHandler(ReturnBuffer); getBufferHandler = new GetBufferHandler(GetBuffer); InitializeBufferPool(); InitializePerformanceCounters(); InitializeNetwork(); InitializeThreads(); }
public void Dispose() { lock(classLock) { try { disposed = true; // Unhook events RtpEvents.ReceiverReport -= new RtpEvents.ReceiverReportEventHandler(RtpReceiverReport); RtpEvents.DuplicateCNameDetected -= new RtpEvents.DuplicateCNameDetectedEventHandler(DuplicateCNameDetected); if(updateThread != null) { updateThread.Dispose(); updateThread = null; } if(rtpSession != null) { rtpSession.Dispose(); rtpSession = null; rtpSender = null; } } catch(Exception e) { eventLog.WriteEntry("Error disposing ConnectivityDetector. \n" + e.ToString(), EventLogEntryType.Error, 0); } } }
// CF1 private void LeaveRtpSession() { UnhookRtpEvents(); if(rtpSession != null) { rtpSession.Dispose(); rtpSession = null; rtpSender = null; rtpStream = null; } }
public HiddenSocketExceptionEventArgs( RtpSession session, System.Net.Sockets.SocketException ex ) { Session = session; Exception = ex; }
/// <summary> /// Join the Venue and start participating. AutoSend default devices if AutoSend == true /// The optional password is used generate a symmetric encryption key... /// </summary> public static void JoinVenue(IVenue venue,String password) { foreach (Participant p in participants.Values) { //If there was an active warning on the local particpant at the time of the //previous venue leave, it needs to be cleaned up. p.ThroughputWarnings.Clear(); } lock(venue) { if (Conference.ActiveVenue != null) { throw new InvalidOperationException(Strings.AlreadyJoinedToVenue); } if (venue.VenueData.VenueType == VenueType.Invalid) { throw new ArgumentException(Strings.InvalidVenueType); } // (pfb) Why are we checking this here? When would it happen? if (rtpSession == null) { // Do this first, or else the locks in the eventHandlers will throw, due to null argument Conference.activeVenue = venue; HookRtpEvents(); #region Start the RtpSession try { // Pri3: Add casting of a Participant to an RtpParticipant Participant p = Conference.LocalParticipant; RtpParticipant rp = new RtpParticipant(p.Identifier, p.Name); rp.Email = p.Email; rp.Location = Conference.Location; rp.Phone = p.Phone; if (Conference.ReflectorEnabled && MSR.LST.Net.Utility.IsMulticast(venue.EndPoint)) { IPEndPoint refEP; IPAddress reflectorIP; // Resolve the reflector address try { reflectorIP = System.Net.Dns.GetHostEntry( Conference.ReflectorAddress).AddressList[0]; } catch(Exception e) { //Starting with .Net 4, passing an IP address to GetHostEntry excepts. We'll check //here to see if the user entered an IP address before rethowing. if (!IPAddress.TryParse(Conference.ReflectorAddress, out reflectorIP)) { throw new Exception(string.Format(CultureInfo.CurrentCulture, Strings.ReflectorAddressNotFound, Conference.ReflectorAddress), e); } } // andrew: reflector registation is now done via UDP, and has been // pushed down into UDPListener... refEP = new IPEndPoint(reflectorIP, ReflectorRtpPort); StartDiagnosticMonitor(venue.Name, venue.EndPoint); rtpSession = new RtpSession(venue.EndPoint, rp, true, true, refEP); if (password != null) { PacketTransform xform = MakePacketTransform(password); rtpSession.PacketTransform = xform; } } else { StartDiagnosticMonitor(venue.Name, venue.EndPoint); rtpSession = new RtpSession(venue.EndPoint, rp, true, true); if (password != null) { PacketTransform xform = MakePacketTransform(password); rtpSession.PacketTransform = xform; } } // andrew: notify RTP of our venue name; this is for diagnostic purposes rtpSession.VenueName = venue.Name; } catch (System.Net.Sockets.SocketException se) { eventLog.WriteEntry(se.ToString(), EventLogEntryType.Error, 99); LeaveVenue(); if (se.ErrorCode == 10013) { throw new Exception(Strings.SecurityErrorOccurredConnecting); } else { throw; } } catch (Exception e) { eventLog.WriteEntry(e.ToString(), EventLogEntryType.Error, 99); LeaveVenue(); throw; } #endregion } } }