r3553 - in trunk/libminisip: . include include/libminisip/media include/libminisip/media/soundcard include/libminisip/media/video include/libminisip/media/video/codec include/libminisip/media/zrtp source/subsystem_media source/subsystem_media/soundcard source/subsystem_media/video source/subsystem_media/zrtp
erik at minisip.org
erik at minisip.org
Thu Dec 13 13:18:13 CET 2007
Author: erik
Date: 2007-12-13 13:18:12 +0100 (Thu, 13 Dec 2007)
New Revision: 3553
Added:
trunk/libminisip/include/libminisip/media/ReliableMedia.h
trunk/libminisip/include/libminisip/media/ReliableMediaServer.h
trunk/libminisip/source/subsystem_media/ReliableMedia.cxx
trunk/libminisip/source/subsystem_media/ReliableMediaServer.cxx
Modified:
trunk/libminisip/Makefile.am
trunk/libminisip/include/Makefile.am
trunk/libminisip/include/libminisip/media/AudioMedia.h
trunk/libminisip/include/libminisip/media/CallRecorder.h
trunk/libminisip/include/libminisip/media/MediaStream.h
trunk/libminisip/include/libminisip/media/RealtimeMedia.h
trunk/libminisip/include/libminisip/media/RtpReceiver.h
trunk/libminisip/include/libminisip/media/soundcard/SoundIO.h
trunk/libminisip/include/libminisip/media/video/VideoMedia.h
trunk/libminisip/include/libminisip/media/video/codec/VideoCodec.h
trunk/libminisip/include/libminisip/media/zrtp/ZrtpHostBridgeMinisip.h
trunk/libminisip/source/subsystem_media/AudioMedia.cxx
trunk/libminisip/source/subsystem_media/CallRecorder.cxx
trunk/libminisip/source/subsystem_media/DtmfSender.cxx
trunk/libminisip/source/subsystem_media/MediaHandler.cxx
trunk/libminisip/source/subsystem_media/MediaStream.cxx
trunk/libminisip/source/subsystem_media/RealtimeMedia.cxx
trunk/libminisip/source/subsystem_media/RtpReceiver.cxx
trunk/libminisip/source/subsystem_media/Session.cxx
trunk/libminisip/source/subsystem_media/Session.h
trunk/libminisip/source/subsystem_media/soundcard/SoundIO.cxx
trunk/libminisip/source/subsystem_media/video/VideoMedia.cxx
trunk/libminisip/source/subsystem_media/zrtp/ZrtpHostBridgeMinisip.cxx
Log:
A step towards support for reliable transport in the media system:
* Renamed MediaStream to RealtimeMediaStream
To have the same SDP processing of both reliable and real-time
media, the "MediaStream" class (which represents an instance
of a media session) should be able to represent all types of
media. This is one step towards having that MediaStream
by renaming the existing one to RealtimeMediaStream. Then we can
re-introduce MediaStream in the next commit and make
both RealtimeMediaStream and ReliableMediaStream sub-classes of
MediaStream. I make this intermediary commit to catch any
"MediaStream" usage that I have not changes (the auto-build
covers more code than I have tried).
* Naming: We used both "unRegister" and "unregister" in the code.
Now we use only "unregister" that was used the most.
This commit should not change the behavour of minisip or add any new
features.
Modified: trunk/libminisip/Makefile.am
===================================================================
--- trunk/libminisip/Makefile.am 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/Makefile.am 2007-12-13 12:18:12 UTC (rev 3553)
@@ -77,6 +77,8 @@
source/subsystem_media/MediaStream.cxx \
source/subsystem_media/Media.cxx \
source/subsystem_media/RealtimeMedia.cxx \
+ source/subsystem_media/ReliableMedia.cxx \
+ source/subsystem_media/ReliableMediaServer.cxx \
source/subsystem_media/RtpReceiver.cxx \
source/subsystem_media/MediaCommandString.cxx \
source/subsystem_media/AudioMedia.cxx \
Modified: trunk/libminisip/include/Makefile.am
===================================================================
--- trunk/libminisip/include/Makefile.am 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/Makefile.am 2007-12-13 12:18:12 UTC (rev 3553)
@@ -11,6 +11,8 @@
libminisip/media/SubsystemMedia.h \
libminisip/media/Media.h \
libminisip/media/RealtimeMedia.h \
+ libminisip/media/ReliableMedia.h \
+ libminisip/media/ReliableMediaServer.h \
libminisip/media/MediaStream.h \
libminisip/media/RtpReceiver.h \
libminisip/media/CallRecorder.h \
Modified: trunk/libminisip/include/libminisip/media/AudioMedia.h
===================================================================
--- trunk/libminisip/include/libminisip/media/AudioMedia.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/AudioMedia.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -88,7 +88,7 @@
* @param sender a reference to the MediaStreamSender object to
* register
*/
- virtual void registerMediaSender( MRef<MediaStreamSender *> sender );
+ virtual void registerRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender );
/**
@@ -97,7 +97,7 @@
* @param sender a reference to the MediaStreamSender object to
* unregister
*/
- virtual void unRegisterMediaSender( MRef<MediaStreamSender *> sender );
+ virtual void unregisterRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender );
/**
* Used to register a new media source. Called upon discovery
* of a new SSRC identifier. Each media source may use
@@ -112,7 +112,7 @@
* @param ssrc the SSRC identifier used by the media source to
* unregister
*/
- virtual void unRegisterMediaSource( uint32_t ssrc );
+ virtual void unregisterMediaSource( uint32_t ssrc );
/**
* Callback used by the SoundIO when sound samples are
Modified: trunk/libminisip/include/libminisip/media/CallRecorder.h
===================================================================
--- trunk/libminisip/include/libminisip/media/CallRecorder.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/CallRecorder.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -32,7 +32,7 @@
#include<libminisip/media/soundcard/FileSoundDevice.h>
template <class T> class MRef;
-class MediaStreamReceiver;
+class RealtimeMediaStreamReceiver;
class AudioMedia;
class RtpReceiver;
class IpProvider;
@@ -45,7 +45,7 @@
The call recorder is to be used to record all audio in & out related
to a particular call.
It inherits from SoundRecorderCallback (to be registered as a recorder receiver
- in SoundIO) and from MediaStreamReceiver (to be registered as a stream receiver
+ in SoundIO) and from RealtimeMediaStreamReceiver (to be registered as a stream receiver
to the associated RtpReceiver).
It implements a producer/consumer model, where we have two producers (one for the
SoundIO::playerLoop() and another for the RtpReceiver::run(). The nice thing
@@ -56,7 +56,7 @@
on bunch of samples from each producer).
*/
class CallRecorder:
- public MediaStreamReceiver,
+ public RealtimeMediaStreamReceiver,
public SoundRecorderCallback {
public:
/**
@@ -96,7 +96,7 @@
#endif
/**
- Inherited from MediaStreamReceiver
+ Inherited from RealtimeMediaStreamReceiver
*/
virtual void handleRtpPacket( MRef<SRtpPacket *> packet, MRef<IPAddress *> from );
// virtual void handleRtpPacket( MRef<SRtpPacket *> packet );
Modified: trunk/libminisip/include/libminisip/media/MediaStream.h
===================================================================
--- trunk/libminisip/include/libminisip/media/MediaStream.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/MediaStream.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -51,7 +51,7 @@
* MediaStreamSender and MediaStreamReceiver
*/
-class LIBMINISIP_API MediaStream : public MObject{
+class LIBMINISIP_API RealtimeMediaStream : public MObject{
public:
/**
* Starts the transmission or reception of a the stream.
@@ -83,7 +83,7 @@
*/
std::list<std::string> getSdpAttributes();
- virtual std::string getMemObjectType() const {return "MediaStream";}
+ virtual std::string getMemObjectType() const {return "RealtimeMediaStream";}
bool disabled;
std::string getCallId(){return callId;}
@@ -160,7 +160,7 @@
protected:
MRef<CryptoContext *> getCryptoContext( uint32_t ssrc, uint16_t seq_no );
- MediaStream( std::string callId, MRef<RealtimeMedia *> );
+ RealtimeMediaStream( std::string callId, MRef<RealtimeMedia *> );
std::string callId;
MRef<RealtimeMedia *> media;
uint32_t csbId;
@@ -181,7 +181,7 @@
* given session. It is responsible for decryption and replay protection
* in the case of SRTP.
*/
-class LIBMINISIP_API MediaStreamReceiver : public MediaStream{
+class LIBMINISIP_API RealtimeMediaStreamReceiver : public RealtimeMediaStream{
public:
/**
* Constructor, called by the MediaHandler when creating
@@ -196,7 +196,7 @@
* used to obtain contact IP address and port in NAT
* traversal mechanism
*/
- MediaStreamReceiver( std::string callId,
+ RealtimeMediaStreamReceiver( std::string callId,
MRef<RealtimeMedia *> media,
MRef<RtpReceiver *> rtpReceiver,
MRef<RtpReceiver *> rtp6Receiver = NULL );
@@ -205,7 +205,7 @@
virtual std::string getDebugString();
#endif
- virtual std::string getMemObjectType() const {return "MediaStreamReceiver";}
+ virtual std::string getMemObjectType() const {return "RealtimeMediaStreamReceiver";}
/**
* Starts the reception of a the stream, by subscribing to
@@ -306,7 +306,7 @@
* a specific media Session. It holds the CODEC instance selected for
* this peer, and is responsible for encryption.
*/
-class LIBMINISIP_API MediaStreamSender : public MediaStream{
+class LIBMINISIP_API RealtimeMediaStreamSender : public RealtimeMediaStream{
public:
/**
* Constructor, used by the MediaHandler during the
@@ -317,7 +317,7 @@
* to which the data should be sent. If NULL a new one
* is created
*/
- MediaStreamSender( std::string callId,
+ RealtimeMediaStreamSender( std::string callId,
MRef<RealtimeMedia *> media,
MRef<UDPSocket *> senderSock=NULL,
MRef<UDPSocket *> sender6Sock=NULL );
@@ -326,7 +326,7 @@
virtual std::string getDebugString();
#endif
- virtual std::string getMemObjectType() const {return "MediaStreamSender";}
+ virtual std::string getMemObjectType() const {return "RealtimeMediaStreamSender";}
/**
* Returns the CODEC instance currently selected for
@@ -352,26 +352,26 @@
* the peer is expecting to receive the data. This
* is extracted from the received session description
* (SDP).
- * @param port the port to which the MediaStreamSender should
+ * @param port the port to which the RealtimeMediaStreamSender should
* send
*/
virtual void setPort( uint16_t port );
/**
* Returns the port to which data is sent.
- * @retunrs the port to which the MediaStreamSender is sending
+ * @retunrs the port to which the RealtimeMediaStreamSender is sending
* data, or 0 if it was not set
*/
virtual uint16_t getPort();
/**
- * Used by the Media to send data, if the MediaStreamSender
+ * Used by the Media to send data, if the RealtimeMediaStreamSender
* has subscribed to the Media. The data will be encrypted
* if required, and encapsulated in an RTP packet.
* @param data a pointer to the data to send
* @param length the lenght of the data to send
* @param ts the timestamp to use in RTP header, or
- * NULL if the MediaStreamSender should decide it
+ * NULL if the RealtimeMediaStreamSender should decide it
* @param marker whether or not the marker should be set
* in the RTP header
* @param dtmf whether or not the data is a DTMF signal
Modified: trunk/libminisip/include/libminisip/media/RealtimeMedia.h
===================================================================
--- trunk/libminisip/include/libminisip/media/RealtimeMedia.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/RealtimeMedia.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -34,7 +34,7 @@
#include<libminisip/media/rtp/RtpPacket.h>
#include<libminisip/media/MediaStream.h>
-class MediaStreamSender;
+class RealtimeMediaStreamSender;
/**
@@ -67,9 +67,9 @@
virtual void playData( MRef<RtpPacket *> rtpPacket )=0;
/**
- * Send the data to all the registered MediaStreamSender.
+ * Send the data to all the registered RealtimeMediaStreamSender.
* If relevant, the data is first encoded using the
- * MediaStream's selected CODEC.
+ * RealtimeMediaStream's selected CODEC.
* @param data pointer to the data to send
* @param length length of the data buffer
* @param ts timestamp to use in the RTP header
@@ -79,14 +79,14 @@
virtual void sendData( byte_t * data, uint32_t length, uint32_t ts, bool marker=false );
/**
- * Used by the media sessions to register a MediaStreamSender.
- * When a MediaStreamSender is registered to a Media object,
+ * Used by the media sessions to register a RealtimeMediaStreamSender.
+ * When a RealtimeMediaStreamSender is registered to a Media object,
* it will be used to send sampled media from the corresponding
* medium
- * @param sender a reference to the MediaStreamSender object to
+ * @param sender a reference to the RealtimeMediaStreamSender object to
* register
*/
- virtual void registerMediaSender( MRef<MediaStreamSender *> sender );
+ virtual void registerRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender );
/**
* Used by the media sessions to unregister a MediaStreamSender,
@@ -94,7 +94,7 @@
* @param sender a reference to the MediaStreamSender object to
* unregister
*/
- virtual void unRegisterMediaSender( MRef<MediaStreamSender *> sender );
+ virtual void unregisterRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender );
/**
* Used to register a new media source. Called upon discovery
@@ -109,7 +109,7 @@
* @param ssrc the SSRC identifier used by the media source to
* unregister
*/
- virtual void unRegisterMediaSource( uint32_t ssrc)=0;
+ virtual void unregisterMediaSource( uint32_t ssrc)=0;
/**
* deprecated...
@@ -147,7 +147,7 @@
std::list< MRef<Codec *> > codecList;
Mutex codecListLock;
- std::list< MRef<MediaStreamSender *> > senders;
+ std::list< MRef<RealtimeMediaStreamSender *> > senders;
Mutex sendersLock;
Mutex sourcesLock;
};
Added: trunk/libminisip/include/libminisip/media/ReliableMedia.h
===================================================================
--- trunk/libminisip/include/libminisip/media/ReliableMedia.h (rev 0)
+++ trunk/libminisip/include/libminisip/media/ReliableMedia.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -0,0 +1,122 @@
+/*
+ Copyright (C) 2004-2007 the Minisip Team
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* Copyright (C) 2004-2007
+ *
+ * Authors: Erik Eliasson <ere at kth.se>
+ * Johan Bilien <jobi at via.ecp.fr>
+*/
+
+
+
+#ifndef RELIABLEMEDIA
+#define RELIABLEMEDIA
+
+#include<libminisip/libminisip_config.h>
+
+#include<libminisip/media/Media.h>
+#include<libminisip/media/codecs/Codec.h>
+#include<libminisip/media/rtp/RtpPacket.h>
+#include<libminisip/media/MediaStream.h>
+
+/**
+ * Handles RTP based media (typically audio and video streams).
+ * It holds a list of the CODEC relevant for
+ * that medium, and other objects used by the medium (SoundIO
+ * for audio, Grabber and Display for video).
+ * Media sessions register their MediaStreamSender objects to
+ * the Media objects.
+ */
+class LIBMINISIP_API ReliableMedia : public Media {
+ public:
+
+ bool isClient;
+ bool isServer;
+
+ ~ReliableMedia();
+
+ virtual std::string getSdpMediaType();
+
+
+ /**
+ * Send the data to all the registered MediaStreamSender.
+ * If relevant, the data is first encoded using the
+ * MediaStream's selected CODEC.
+ * @param data pointer to the data to send
+ * @param length length of the data buffer
+ * @param ts timestamp to use in the RTP header
+ * @param marker whether or not the marker should be set
+ * in the RTP header
+ */
+ // virtual void sendData( byte_t * data, uint32_t length, uint32_t ts, bool marker=false );
+
+
+
+ /**
+ * Used by the media sessions to register a MediaStreamSender.
+ * When a MediaStreamSender is registered to a Media object,
+ * it will be used to send sampled media from the corresponding
+ * medium
+ * @param sender a reference to the MediaStreamSender object to
+ * register
+ */
+// virtual void registerMediaSender( MRef<MediaStreamSender *> sender );
+
+ /**
+ * Used by the media sessions to unregister a MediaStreamSender,
+ * when a media session ends.
+ * @param sender a reference to the MediaStreamSender object to
+ * unregister
+ */
+// virtual void unregisterMediaSender( MRef<MediaStreamSender *> sender );
+
+
+
+ /**
+ * Used to register a new media source. Called upon discovery
+ * of a new SSRC identifier. Each media source may use
+ * a different decoder.
+ * @param ssrc the SSRC identifier used by the new media source
+ */
+// virtual void registerMediaSource( uint32_t ssrc, std::string callId )=0;
+
+ /**
+ * Used to unregister a media source when the session ends.
+ * @param ssrc the SSRC identifier used by the media source to
+ * unregister
+ */
+// virtual void unregisterMediaSource( uint32_t ssrc)=0;
+
+
+ protected:
+ ReliableMedia( std::string sdpType, bool isClient, bool isServer );
+
+ std::string sdpType;
+
+// ReliableMedia( std::list<MRef<Codec *> > codecList );
+
+// std::list< MRef<Codec *> > codecList;
+// Mutex codecListLock;
+
+// std::list< MRef<MediaStreamSender *> > senders;
+// Mutex sendersLock;
+// Mutex sourcesLock;
+};
+
+
+#endif
Added: trunk/libminisip/include/libminisip/media/ReliableMediaServer.h
===================================================================
--- trunk/libminisip/include/libminisip/media/ReliableMediaServer.h (rev 0)
+++ trunk/libminisip/include/libminisip/media/ReliableMediaServer.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -0,0 +1,108 @@
+/*
+ Copyright (C) 2004-2007 the Minisip Team
+
+ This library is free software; you can redistribute it and/or
+ modify it under the terms of the GNU Lesser General Public
+ License as published by the Free Software Foundation; either
+ version 2.1 of the License, or (at your option) any later version.
+
+ This library is distributed in the hope that it will be useful,
+ but WITHOUT ANY WARRANTY; without even the implied warranty of
+ MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
+ Lesser General Public License for more details.
+
+ You should have received a copy of the GNU Lesser General Public
+ License along with this library; if not, write to the Free Software
+ Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
+ */
+
+/* Copyright (C) 2004-2007
+ *
+ * Authors: Erik Eliasson <ere at kth.se>
+ * Johan Bilien <jobi at via.ecp.fr>
+*/
+
+
+
+#ifndef RELIABLEMEDIASERVER
+#define RELIABLEMEDIASERVER
+
+#include<libminisip/libminisip_config.h>
+
+#include<libminisip/media/Media.h>
+
+
+/**
+ * Handles an offered resource.
+ */
+class LIBMINISIP_API ReliableMediaServer : public Media {
+ public:
+
+// ReliableMediaServer(std::string type):sdpType(type){}
+ ~ReliableMediaServer();
+
+ virtual std::string getSdpMediaType(){return sdpType;}
+
+ virtual std::list<std::string> getSdpAttributes()=0;
+
+ virtual uint16_t getPort(){return 33;}; //FIXME: DEBUGING!!!!!!
+
+
+ /**
+ * Send the data to all the registered MediaStreamSender.
+ * If relevant, the data is first encoded using the
+ * MediaStream's selected CODEC.
+ * @param data pointer to the data to send
+ * @param length length of the data buffer
+ * @param ts timestamp to use in the RTP header
+ * @param marker whether or not the marker should be set
+ * in the RTP header
+ */
+ // virtual void sendData( byte_t * data, uint32_t length, uint32_t ts, bool marker=false );
+
+
+
+ /**
+ * Used by the media sessions to register a MediaStreamSender.
+ * When a MediaStreamSender is registered to a Media object,
+ * it will be used to send sampled media from the corresponding
+ * medium
+ * @param sender a reference to the MediaStreamSender object to
+ * register
+ */
+// virtual void registerMediaSender( MRef<MediaStreamSender *> sender );
+
+ /**
+ * Used by the media sessions to unregister a MediaStreamSender,
+ * when a media session ends.
+ * @param sender a reference to the MediaStreamSender object to
+ * unregister
+ */
+// virtual void unregisterMediaSender( MRef<MediaStreamSender *> sender );
+
+
+
+ /**
+ * Used to register a new media source. Called upon discovery
+ * of a new SSRC identifier. Each media source may use
+ * a different decoder.
+ * @param ssrc the SSRC identifier used by the new media source
+ */
+// virtual void registerMediaSource( uint32_t ssrc, std::string callId )=0;
+
+ /**
+ * Used to unregister a media source when the session ends.
+ * @param ssrc the SSRC identifier used by the media source to
+ * unregister
+ */
+// virtual void unregisterMediaSource( uint32_t ssrc)=0;
+
+
+ protected:
+ ReliableMediaServer( std::string sdpType);
+
+ std::string sdpType;
+};
+
+
+#endif
Modified: trunk/libminisip/include/libminisip/media/RtpReceiver.h
===================================================================
--- trunk/libminisip/include/libminisip/media/RtpReceiver.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/RtpReceiver.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -34,13 +34,13 @@
#include<libminisip/ipprovider/IpProvider.h>
class UDPSocket;
-class MediaStreamReceiver;
+class RealtimeMediaStreamReceiver;
class CryptoContext;
/**
* The RtpReceiver is used to listen on a UDPSocket and demultiplex
* several incoming streams, depending on their payload type.
- * MediaStreamReceiver objects register to it when they are ready
+ * RealtimeMediaStreamReceiver objects register to it when they are ready
* to receive a specific media type.
*/
class LIBMINISIP_API RtpReceiver : public Runnable{
@@ -56,23 +56,23 @@
RtpReceiver( MRef<IpProvider *> ipProvider, std::string callId );
/**
- * Used for a MediaStreamReceiver to subscribe to data
+ * Used for a RealtimeMediaStreamReceiver to subscribe to data
* incoming on this RtpReceiver. If the payload type
- * is handled by the MediaStreamReceiver, the data
+ * is handled by the RealtimeMediaStreamReceiver, the data
* is sent to it.
- * @param mediaStream a reference to the MediaStreamReceiver
+ * @param RealtimeMediaStream a reference to the RealtimeMediaStreamReceiver
* object to subscribe
*/
- void registerMediaStream( MRef<MediaStreamReceiver *> mediaStream );
+ void registerRealtimeMediaStream( MRef<RealtimeMediaStreamReceiver *> realtimeMediaStream );
/**
- * Used to signify that a MediaStreamReceiver should no
+ * Used to signify that a RealtimeMediaStreamReceiver should no
* longer receive data from this RtpReceiver. Used
* when the media Session is stopped.
- * @param mediaStream a reference to the MediaStreamReceiver
+ * @param RealtimeMediaStream a reference to the RealtimeMediaStreamReceiver
* object that should be unsubscribed
*/
- void unregisterMediaStream( MRef<MediaStreamReceiver *> mediaStream);
+ void unregisterRealtimeMediaStream( MRef<RealtimeMediaStreamReceiver *> realtimeMediaStream);
/**
* Listening thread main loop.
@@ -112,9 +112,9 @@
uint16_t externalPort;
bool kill;
- std::list< MRef<MediaStreamReceiver *> > mediaStreams;
+ std::list< MRef<RealtimeMediaStreamReceiver *> > realtimeMediaStreams;
- Mutex mediaStreamsLock;
+ Mutex realtimeMediaStreamsLock;
Thread * thread;
Modified: trunk/libminisip/include/libminisip/media/soundcard/SoundIO.h
===================================================================
--- trunk/libminisip/include/libminisip/media/soundcard/SoundIO.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/soundcard/SoundIO.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -148,7 +148,7 @@
int32_t nrsamples,
bool stereo);
- void unRegisterRecorderReceiver( SoundRecorderCallback *callback );
+ void unregisterRecorderReceiver( SoundRecorderCallback *callback );
/**
* Starts the thread that "polls" the soundcard for data
@@ -166,7 +166,7 @@
void registerSource(MRef<SoundSource *> source);
- void unRegisterSource(int sourceId);
+ void unregisterSource(int sourceId);
/**
* Starts thread that takes data from queue
Modified: trunk/libminisip/include/libminisip/media/video/VideoMedia.h
===================================================================
--- trunk/libminisip/include/libminisip/media/video/VideoMedia.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/video/VideoMedia.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -60,10 +60,10 @@
virtual void sendVideoData( byte_t * data, uint32_t length, uint32_t ts, bool marker=false );
- virtual void registerMediaSender( MRef<MediaStreamSender *> sender );
- virtual void unRegisterMediaSender( MRef<MediaStreamSender *> sender );
+ virtual void registerMediaSender( MRef<RealtimeMediaStreamSender *> sender );
+ virtual void unregisterMediaSender( MRef<RealtimeMediaStreamSender *> sender );
virtual void registerMediaSource( uint32_t ssrc, std::string callId );
- virtual void unRegisterMediaSource( uint32_t ssrc );
+ virtual void unregisterMediaSource( uint32_t ssrc );
virtual void handleMHeader( MRef<SdpHeaderM *> m );
Modified: trunk/libminisip/include/libminisip/media/video/codec/VideoCodec.h
===================================================================
--- trunk/libminisip/include/libminisip/media/video/codec/VideoCodec.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/video/codec/VideoCodec.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -30,7 +30,7 @@
#include<libminisip/media/video/ImageHandler.h>
#include<libminisip/media/codecs/Codec.h>
-class MediaStreamSender;
+class RealtimeMediaStreamSender;
class AVEncoder;
class AVDecoder;
class Grabber;
@@ -70,7 +70,7 @@
private:
- MRef<MediaStreamSender *> senders;
+ MRef<RealtimeMediaStreamSender *> senders;
MRef<AVEncoder *> coder;
MRef<AVDecoder *> decoder;
Modified: trunk/libminisip/include/libminisip/media/zrtp/ZrtpHostBridgeMinisip.h
===================================================================
--- trunk/libminisip/include/libminisip/media/zrtp/ZrtpHostBridgeMinisip.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/include/libminisip/media/zrtp/ZrtpHostBridgeMinisip.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -42,8 +42,8 @@
#include <libzrtpcpp/ZrtpCallback.h>
#include <libzrtpcpp/ZRtp.h>
-class MediaStreamReceiver;
-class MediaStreamSender;
+class RealtimeMediaStreamReceiver;
+class RealtimeMediaStreamSender;
/**
* The connection between the ZRTP implementation and Minisip.
@@ -114,11 +114,11 @@
void start();
void stop();
- void setReceiver(MRef<MediaStreamReceiver *> r);
+ void setReceiver(MRef<RealtimeMediaStreamReceiver *> r);
void setSsrcReceiver(uint32_t ssrc) { receiverSsrc = ssrc; };
uint32_t getSsrcReceiver() { return receiverSsrc; };
- void setSender(MRef<MediaStreamSender *> s);
+ void setSender(MRef<RealtimeMediaStreamSender *> s);
void setSsrcSender(uint32_t ssrc) { senderSsrc = ssrc; };
uint32_t getSsrcSender() { return senderSsrc; };
@@ -131,7 +131,7 @@
* The host (Minisip) shall call this mehtod to set the IP address
* of the remote peer. We use the address to find the right ZRTP
* host bridge when we receive packets on the receiver port
- * allocated by the MediaStreamReceiver.
+ * allocated by the RealtimeMediaStreamReceiver.
*
* This is (fairly) save because one remote peer shall not have
* several different RTP sessions for one of my receiver ports.
@@ -325,12 +325,12 @@
MRef<IPAddress *> remoteAddress;
- MRef<MediaStreamReceiver *> rStream;
+ MRef<RealtimeMediaStreamReceiver *> rStream;
uint32_t receiverSsrc;
uint32_t receiverSecure;
uint16_t receiverSeqNo;
- MRef<MediaStreamSender *> sStream;
+ MRef<RealtimeMediaStreamSender *> sStream;
uint32_t senderSsrc;
uint32_t senderSecure;
Modified: trunk/libminisip/source/subsystem_media/AudioMedia.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/AudioMedia.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/AudioMedia.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -103,7 +103,7 @@
audioForwarding=b;
}
-void AudioMedia::registerMediaSender( MRef<MediaStreamSender *> sender ){
+void AudioMedia::registerRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender ){
sendersLock.lock();
if( senders.empty() ){
sendersLock.unlock();
@@ -112,9 +112,9 @@
}
//Don't add if it's already in the list. This is so that we support
- //multiple calls to MediaStream::start().
+ //multiple calls to RealtimeMediaStream::start().
bool found=false;
- list<MRef<MediaStreamSender *> >::iterator i;
+ list<MRef<RealtimeMediaStreamSender *> >::iterator i;
for (i=senders.begin(); i!=senders.end(); i++)
if ( *i == sender)
found = true;
@@ -123,7 +123,7 @@
sendersLock.unlock();
}
-void AudioMedia::unRegisterMediaSender( MRef<MediaStreamSender *> sender ){
+void AudioMedia::unregisterRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender ){
bool emptyList;
sendersLock.lock();
senders.remove( sender );
@@ -143,10 +143,10 @@
sources.push_back( source );
}
-void AudioMedia::unRegisterMediaSource( uint32_t ssrc ){
+void AudioMedia::unregisterMediaSource( uint32_t ssrc ){
std::list< MRef<AudioMediaSource *> >::iterator iSource;
- soundIo->unRegisterSource( ssrc );
+ soundIo->unregisterSource( ssrc );
for( iSource = sources.begin(); iSource != sources.end(); iSource ++ ){
if( (*iSource)->getSsrc() == ssrc ){
@@ -203,8 +203,8 @@
for( uint32_t i = 0; i<length; i++ ) zeroData[i] = 0;
}
- list< MRef<MediaStreamSender *> >::iterator i;
- list< MRef<MediaStreamReceiver *> >::iterator ir;
+ list< MRef<RealtimeMediaStreamSender *> >::iterator i;
+ list< MRef<RealtimeMediaStreamReceiver *> >::iterator ir;
list< MRef<Session*> >::iterator is;
sendersLock.lock();
@@ -265,14 +265,14 @@
}
void AudioMedia::stopRinging(){
- soundIo->unRegisterSource( RINGTONE_SOURCE_ID );
+ soundIo->unregisterSource( RINGTONE_SOURCE_ID );
}
#ifdef DEBUG_OUTPUT
string AudioMedia::getDebugString() {
string ret;
ret = getMemObjectType() + ": this=" + itoa(reinterpret_cast<int64_t>(this));
- for( std::list< MRef<MediaStreamSender *> >::iterator it = senders.begin();
+ for( std::list< MRef<RealtimeMediaStreamSender *> >::iterator it = senders.begin();
it != senders.end(); it++ ) {
ret += (*it)->getDebugString() + ";";
}
Modified: trunk/libminisip/source/subsystem_media/CallRecorder.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/CallRecorder.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/CallRecorder.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -41,7 +41,7 @@
CallRecorder::CallRecorder( MRef<AudioMedia *> aMedia,
MRef<RtpReceiver *> rtpReceiver_,
MRef<IpProvider *> ipProvider ):
- MediaStreamReceiver( "callrecorder", (RealtimeMedia *)*aMedia, rtpReceiver_ ),
+ RealtimeMediaStreamReceiver( "callrecorder", (RealtimeMedia *)*aMedia, rtpReceiver_ ),
enabledMic(false),
enabledNtwk(false),
fileDev( NULL ),
@@ -92,7 +92,7 @@
}
}
if (audioMedia)
- audioMedia->getSoundIO()->unRegisterRecorderReceiver( this );
+ audioMedia->getSoundIO()->unregisterRecorderReceiver( this );
if( micData!=NULL ) delete micData;
if( ntwkData!=NULL ) delete ntwkData;
//
@@ -100,7 +100,7 @@
void CallRecorder::free(){
if (audioMedia)
- audioMedia->getSoundIO()->unRegisterRecorderReceiver( this );
+ audioMedia->getSoundIO()->unregisterRecorderReceiver( this );
audioMedia=NULL;
//free inherited references
Modified: trunk/libminisip/source/subsystem_media/DtmfSender.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/DtmfSender.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/DtmfSender.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -54,18 +54,18 @@
}
void DtmfSender::sendPayload( byte_t payload[], bool mark, uint32_t * ts ){
- std::list<MRef<MediaStreamSender *> >::iterator iSender;
+ std::list<MRef<RealtimeMediaStreamSender *> >::iterator iSender;
- session->mediaStreamSendersLock.lock();
- for( iSender = session->mediaStreamSenders.begin();
- iSender != session->mediaStreamSenders.end();
+ session->realtimeMediaStreamSendersLock.lock();
+ for( iSender = session->realtimeMediaStreamSenders.begin();
+ iSender != session->realtimeMediaStreamSenders.end();
iSender++ ){
if( !(**iSender)->disabled ){
- ((MediaStreamSender *)(**iSender))->send( payload, 4, ts, mark, true );
+ ((RealtimeMediaStreamSender *)(**iSender))->send( payload, 4, ts, mark, true );
}
}
- session->mediaStreamSendersLock.unlock();
+ session->realtimeMediaStreamSendersLock.unlock();
}
Modified: trunk/libminisip/source/subsystem_media/MediaHandler.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/MediaHandler.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/MediaHandler.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -37,6 +37,7 @@
#include<libminisip/media/zrtp/ZrtpHostBridgeMinisip.h>
#include<libminisip/media/Media.h>
+#include<libminisip/media/ReliableMedia.h>
#include<libminisip/media/RtpReceiver.h>
#include<libminisip/media/MediaCommandString.h>
#include<libmnetutil/UDPSocket.h>
@@ -121,22 +122,36 @@
for( i = media.begin(); i != media.end(); i++ ){
MRef<Media *> m = *i;
- MRef<RealtimeMedia*> rm = dynamic_cast<RealtimeMedia*>(*m);
+ MRef<RealtimeMedia*> rtm = dynamic_cast<RealtimeMedia*>(*m);
+ MRef<ReliableMedia*> relm = dynamic_cast<ReliableMedia*>(*m);
- if( rm && rm->receive ){
+ if (relm){
+ //TODO: SDP support for reliable media not implemented
+ if (relm->isClient){
+
+
+ }
+ if (relm->isServer){
+
+
+ }
+
+ }
+
+ if( rtm && rtm->receive ){
if( ipProvider )
rtpReceiver = new RtpReceiver( ipProvider, callId );
if( ip6Provider )
rtp6Receiver = new RtpReceiver( ip6Provider, callId );
- MRef<MediaStreamReceiver *> rStream;
- rStream = new MediaStreamReceiver( callId, rm, rtpReceiver, rtp6Receiver );
- session->addMediaStreamReceiver( rStream );
+ MRef<RealtimeMediaStreamReceiver *> rStream;
+ rStream = new RealtimeMediaStreamReceiver( callId, rtm, rtpReceiver, rtp6Receiver );
+ session->addRealtimeMediaStreamReceiver( rStream );
// Need to dereference MRef:s, Can't compare MRef:s
// of different types
- if( *rm == *audioMedia ) {
+ if( *rtm == *audioMedia ) {
CallRecorder * cr;
cr = new CallRecorder( audioMedia, rtpReceiver, ipProvider );
session->callRecorder = cr;
@@ -154,7 +169,7 @@
#endif
}
- if( rm->send ){
+ if( rtm && rtm->send ){
if( !rtpReceiver && !ipProvider.isNull() ){
rtpReceiver = new RtpReceiver( ipProvider, callId );
}
@@ -171,9 +186,9 @@
if( rtp6Receiver )
sock6 = rtp6Receiver->getSocket();
- MRef<MediaStreamSender *> sStream;
- sStream = new MediaStreamSender( callId, rm, sock, sock6 );
- session->addMediaStreamSender( sStream );
+ MRef<RealtimeMediaStreamSender *> sStream;
+ sStream = new RealtimeMediaStreamSender( callId, rtm, sock, sock6 );
+ session->addRealtimeMediaStreamSender( sStream );
#ifdef ZRTP_SUPPORT
if(/*securityConfig.use_zrtp*/ id->use_zrtp) {
#ifdef DEBUG_OUTPUT
Modified: trunk/libminisip/source/subsystem_media/MediaStream.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/MediaStream.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/MediaStream.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -47,21 +47,21 @@
using namespace std;
-MediaStream::MediaStream( string cid, MRef<RealtimeMedia *> m) : callId(cid), media(m),ka(NULL) {
+RealtimeMediaStream::RealtimeMediaStream( string cid, MRef<RealtimeMedia *> m) : callId(cid), media(m),ka(NULL) {
disabled = false;
#ifdef ZRTP_SUPPORT
zrtpBridge = NULL;
#endif
}
-std::string MediaStream::getSdpMediaType(){
+std::string RealtimeMediaStream::getSdpMediaType(){
if( media ){
return media->getSdpMediaType();
}
return "";
}
-list<string> MediaStream::getSdpAttributes(){
+list<string> RealtimeMediaStream::getSdpAttributes(){
return media->getSdpAttributes();
}
@@ -84,7 +84,7 @@
return true;
}
-bool MediaStream::matches( MRef<SdpHeaderM *> m, uint32_t formatIndex ){
+bool RealtimeMediaStream::matches( MRef<SdpHeaderM *> m, uint32_t formatIndex ){
string sdpRtpMap;
string sdpFmtpParam;
@@ -149,7 +149,7 @@
return false;
}
-MRef<CryptoContext *> MediaStream::initCrypto( uint32_t ssrc, uint16_t seq_no ){
+MRef<CryptoContext *> RealtimeMediaStream::initCrypto( uint32_t ssrc, uint16_t seq_no ){
MRef<CryptoContext *> cryptoContext;
kaLock.lock();
@@ -216,7 +216,7 @@
return cryptoContext;
}
-MRef<CryptoContext *> MediaStream::getCryptoContext( uint32_t ssrc, uint16_t seq_no ){
+MRef<CryptoContext *> RealtimeMediaStream::getCryptoContext( uint32_t ssrc, uint16_t seq_no ){
kaLock.lock();
list< MRef<CryptoContext *> >::iterator i;
@@ -231,7 +231,7 @@
return initCrypto( ssrc, seq_no );
}
-void MediaStream::setKeyAgreement( MRef<KeyAgreement *> ka_ ){
+void RealtimeMediaStream::setKeyAgreement( MRef<KeyAgreement *> ka_ ){
kaLock.lock();
this->ka = ka_;
@@ -250,7 +250,7 @@
* incomming RTP sessions, they are identified by the SSRC. A sender
* handles one stream (media stream) to the remote peer only.
*/
-void MediaStream::setKeyAgreementZrtp(MRef<CryptoContext *>cx) {
+void RealtimeMediaStream::setKeyAgreementZrtp(MRef<CryptoContext *>cx) {
kaLock.lock();
@@ -267,20 +267,20 @@
kaLock.unlock();
}
-void MediaStream::setZrtpHostBridge(MRef<ZrtpHostBridgeMinisip *> zsb) {
+void RealtimeMediaStream::setZrtpHostBridge(MRef<ZrtpHostBridgeMinisip *> zsb) {
zrtpBridge = zsb;
}
-MRef<ZrtpHostBridgeMinisip *> MediaStream::getZrtpHostBridge() {
+MRef<ZrtpHostBridgeMinisip *> RealtimeMediaStream::getZrtpHostBridge() {
return zrtpBridge;
}
#endif
-MediaStreamReceiver::MediaStreamReceiver( string callid, MRef<RealtimeMedia *> m,
+RealtimeMediaStreamReceiver::RealtimeMediaStreamReceiver( string callid, MRef<RealtimeMedia *> m,
MRef<RtpReceiver *> rtpRecv,
MRef<RtpReceiver *> rtp6Recv ):
- MediaStream( callid, m ),
+ RealtimeMediaStream( callid, m ),
rtpReceiver( rtpRecv ),
rtp6Receiver( rtp6Recv ){
id = rand();
@@ -289,29 +289,29 @@
codecList = m->getAvailableCodecs();
}
-uint32_t MediaStreamReceiver::getId(){
+uint32_t RealtimeMediaStreamReceiver::getId(){
return id;
}
-void MediaStreamReceiver::start(){
+void RealtimeMediaStreamReceiver::start(){
if( !running ){
if( rtpReceiver ){
- rtpReceiver->registerMediaStream( this );
+ rtpReceiver->registerRealtimeMediaStream( this );
}
if( rtp6Receiver )
- rtp6Receiver->registerMediaStream( this );
+ rtp6Receiver->registerRealtimeMediaStream( this );
running = true;
}
}
-void MediaStreamReceiver::stop(){
+void RealtimeMediaStreamReceiver::stop(){
list<uint32_t>::iterator i;
if( rtpReceiver ){
- rtpReceiver->unregisterMediaStream( this );
+ rtpReceiver->unregisterRealtimeMediaStream( this );
rtpReceiver->stop();
}
if( rtp6Receiver ){
- rtp6Receiver->unregisterMediaStream( this );
+ rtp6Receiver->unregisterRealtimeMediaStream( this );
rtp6Receiver->stop();
}
if( rtpReceiver )
@@ -322,7 +322,7 @@
ssrcListLock.lock();
for( i = ssrcList.begin(); i != ssrcList.end(); i++ ){
- media->unRegisterMediaSource( *i );
+ media->unregisterMediaSource( *i );
}
ssrcList.clear();
ssrcListLock.unlock();
@@ -330,12 +330,12 @@
running = false;
}
-uint16_t MediaStreamReceiver::getPort(){
+uint16_t RealtimeMediaStreamReceiver::getPort(){
return rtpReceiver ? rtpReceiver->getPort() : ( rtp6Receiver ? rtp6Receiver->getPort() : 0 );
}
#ifdef ZRTP_SUPPORT
-void MediaStreamReceiver::handleRtpPacketExt(MRef<SRtpPacket *> packet) {
+void RealtimeMediaStreamReceiver::handleRtpPacketExt(MRef<SRtpPacket *> packet) {
uint32_t recvSsrc;
uint16_t seq_no;
@@ -359,7 +359,7 @@
}
#endif
-void MediaStreamReceiver::handleRtpPacket( MRef<SRtpPacket *> packet, string callId, MRef<IPAddress *> from ){
+void RealtimeMediaStreamReceiver::handleRtpPacket( MRef<SRtpPacket *> packet, string callId, MRef<IPAddress *> from ){
uint32_t packetSsrc;
uint16_t seq_no;
@@ -412,7 +412,7 @@
media->playData( *packet );
}
-void MediaStreamReceiver::gotSsrc( uint32_t ssrc, string callId ){
+void RealtimeMediaStreamReceiver::gotSsrc( uint32_t ssrc, string callId ){
list<uint32_t>::iterator i;
ssrcListLock.lock();
@@ -429,12 +429,12 @@
ssrcListLock.unlock();
}
-std::list<MRef<Codec *> > MediaStreamReceiver::getAvailableCodecs(){
+std::list<MRef<Codec *> > RealtimeMediaStreamReceiver::getAvailableCodecs(){
return codecList;
}
-uint16_t MediaStreamReceiver::getPort( const string &addrType ){
+uint16_t RealtimeMediaStreamReceiver::getPort( const string &addrType ){
if( addrType == "IP4" && rtpReceiver )
return rtpReceiver->getPort();
else if( addrType == "IP6" && rtp6Receiver )
@@ -443,10 +443,10 @@
}
-MediaStreamSender::MediaStreamSender( string callid, MRef<RealtimeMedia *> m,
+RealtimeMediaStreamSender::RealtimeMediaStreamSender( string callid, MRef<RealtimeMedia *> m,
MRef<UDPSocket *> senderSocket,
MRef<UDPSocket *> sender6Socket ):
- MediaStream( callid, m ){
+ RealtimeMediaStream( callid, m ){
selectedCodec = NULL;
remotePort = 0;
seqNo = (uint16_t)rand();
@@ -466,12 +466,12 @@
this->sender6Sock = sender6Socket;
}
-void MediaStreamSender::start(){
- media->registerMediaSender( this );
+void RealtimeMediaStreamSender::start(){
+ media->registerRealtimeMediaSender( this );
}
-void MediaStreamSender::stop(){
- media->unRegisterMediaSender( this );
+void RealtimeMediaStreamSender::stop(){
+ media->unregisterRealtimeMediaSender( this );
senderSock = NULL;
sender6Sock = NULL;
@@ -482,11 +482,11 @@
#endif
}
-void MediaStreamSender::setPort( uint16_t port ){
+void RealtimeMediaStreamSender::setPort( uint16_t port ){
remotePort = port;
}
-uint16_t MediaStreamSender::getPort(){
+uint16_t RealtimeMediaStreamSender::getPort(){
return remotePort;
}
@@ -502,11 +502,11 @@
* contexts.
*/
#ifdef ZRTP_SUPPORT
-void MediaStreamSender::sendZrtp(unsigned char* data, int length,
+void RealtimeMediaStreamSender::sendZrtp(unsigned char* data, int length,
unsigned char* payload, int payLen) {
if (this->remoteAddress.isNull()) {
- mdbg("media/zrtp") << " MediaStreamSender::sendZrtp called before " <<
+ mdbg("media/zrtp") << " RealtimeMediaStreamSender::sendZrtp called before " <<
"setRemoteAddress!" << endl;
return;
}
@@ -537,9 +537,9 @@
}
#endif // ZRTP_SUPPORT
-void MediaStreamSender::send( byte_t * data, uint32_t length, uint32_t * givenTs, bool marker, bool dtmf ){
+void RealtimeMediaStreamSender::send( byte_t * data, uint32_t length, uint32_t * givenTs, bool marker, bool dtmf ){
if (this->remoteAddress.isNull()) {
- mdbg("media") << " MediaStreamSender::send called before " <<
+ mdbg("media") << " RealtimeMediaStreamSender::send called before " <<
"setRemoteAddress!" << endl;
return;
}
@@ -602,8 +602,8 @@
}
-void MediaStreamSender::setRemoteAddress( MRef<IPAddress *> ra){
- mdbg("media") << "MediaStreamSender::setRemoteAddress: " <<
+void RealtimeMediaStreamSender::setRemoteAddress( MRef<IPAddress *> ra){
+ mdbg("media") << "RealtimeMediaStreamSender::setRemoteAddress: " <<
ra->getString() << endl;
this->remoteAddress = ra;
#ifdef ZRTP_SUPPORT
@@ -614,14 +614,14 @@
}
#ifdef DEBUG_OUTPUT
-string MediaStream::getDebugString() {
+string RealtimeMediaStream::getDebugString() {
string ret;
ret = getMemObjectType() + " this=" + itoa(reinterpret_cast<int64_t>(this)) +
": port=" + itoa(getPort());
return ret;
}
-string MediaStreamReceiver::getDebugString() {
+string RealtimeMediaStreamReceiver::getDebugString() {
string ret;
ret = getMemObjectType() + " this=" + itoa(reinterpret_cast<int64_t>(this)) +
": listening port=" + itoa(getPort());
@@ -632,7 +632,7 @@
}
return ret;
}
-string MediaStreamSender::getDebugString() {
+string RealtimeMediaStreamSender::getDebugString() {
string ret;
ret = getMemObjectType() + " this=" + itoa(reinterpret_cast<int64_t>(this)) +
@@ -651,7 +651,7 @@
//packet every now and then.
//Max indicates every how many silenced packets we send one keep-alive
//It returns true if the packet needs to be let through, false otherwise
-bool MediaStreamSender::muteKeepAlive( uint32_t max ) {
+bool RealtimeMediaStreamSender::muteKeepAlive( uint32_t max ) {
bool ret = false;
//if muted, only return true if packet is keep alive
@@ -668,8 +668,8 @@
return ret;
}
-bool MediaStreamSender::matches( MRef<SdpHeaderM *> m, uint32_t formatIndex ){
- bool result = MediaStream::matches( m, formatIndex );
+bool RealtimeMediaStreamSender::matches( MRef<SdpHeaderM *> m, uint32_t formatIndex ){
+ bool result = RealtimeMediaStream::matches( m, formatIndex );
if( result && !selectedCodec ){
selectedCodec = media->createCodecInstance(
@@ -680,6 +680,6 @@
return result;
}
-uint32_t MediaStreamSender::getSsrc(){
+uint32_t RealtimeMediaStreamSender::getSsrc(){
return ssrc;
}
Modified: trunk/libminisip/source/subsystem_media/RealtimeMedia.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/RealtimeMedia.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/RealtimeMedia.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -1,4 +1,6 @@
+#include<config.h>
+
#include<libminisip/media/RealtimeMedia.h>
using namespace std;
@@ -41,20 +43,20 @@
return copy;
}
-void RealtimeMedia::registerMediaSender( MRef<MediaStreamSender *> sender ){
+void RealtimeMedia::registerRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender ){
sendersLock.lock();
senders.push_back( sender );
sendersLock.unlock();
}
-void RealtimeMedia::unRegisterMediaSender( MRef<MediaStreamSender *> sender ){
+void RealtimeMedia::unregisterRealtimeMediaSender( MRef<RealtimeMediaStreamSender *> sender ){
sendersLock.lock();
senders.remove( sender );
sendersLock.unlock();
}
void RealtimeMedia::sendData( byte_t * data, uint32_t length, uint32_t ts, bool marker ){
- list< MRef<MediaStreamSender *> >::iterator i;
+ list< MRef<RealtimeMediaStreamSender *> >::iterator i;
sendersLock.lock();
for( i = senders.begin(); i != senders.end(); i++ ){
//only send if active sender, or if muted only if keep-alive
Added: trunk/libminisip/source/subsystem_media/ReliableMedia.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/ReliableMedia.cxx (rev 0)
+++ trunk/libminisip/source/subsystem_media/ReliableMedia.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -0,0 +1,23 @@
+
+#include<config.h>
+
+#include<libminisip/media/ReliableMedia.h>
+
+using namespace std;
+
+ReliableMedia::ReliableMedia(string type, bool isClient_, bool isServer_)
+ : isClient(isClient_),
+ isServer(isServer_),
+ sdpType(type)
+{
+
+}
+
+ReliableMedia::~ReliableMedia(){
+
+}
+
+string ReliableMedia::getSdpMediaType(){
+ return sdpType;
+}
+
Added: trunk/libminisip/source/subsystem_media/ReliableMediaServer.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/ReliableMediaServer.cxx (rev 0)
+++ trunk/libminisip/source/subsystem_media/ReliableMediaServer.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -0,0 +1,17 @@
+
+#include<config.h>
+
+#include<libminisip/media/ReliableMediaServer.h>
+
+using namespace std;
+
+ReliableMediaServer::ReliableMediaServer(string type)
+ : sdpType(type)
+{
+
+}
+
+ReliableMediaServer::~ReliableMediaServer(){
+
+}
+
Modified: trunk/libminisip/source/subsystem_media/RtpReceiver.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/RtpReceiver.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/RtpReceiver.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -123,48 +123,48 @@
}
/**
- register a mediaStreamReceiver ... if the receiver is already registered,
+ register a RealtimeMediaStreamReceiver ... if the receiver is already registered,
update the exhisting one to point to the new receiver.
*/
-void RtpReceiver::registerMediaStream( MRef<MediaStreamReceiver *> mediaStream ){
- list< MRef<MediaStreamReceiver *> >::iterator iter;
- mediaStreamsLock.lock();
+void RtpReceiver::registerRealtimeMediaStream( MRef<RealtimeMediaStreamReceiver *> realtimeMediaStream ){
+ list< MRef<RealtimeMediaStreamReceiver *> >::iterator iter;
+ realtimeMediaStreamsLock.lock();
/* Don't register new streams if the receiver is being closed */
if( !kill ){
bool found = false;
- //cerr << "RtpReceiver::registerMediaStream: register done!" << endl;
- for( iter = mediaStreams.begin();
- iter != mediaStreams.end();
+ //cerr << "RtpReceiver::registerRealtimeMediaStream: register done!" << endl;
+ for( iter = realtimeMediaStreams.begin();
+ iter != realtimeMediaStreams.end();
iter++ ) {
- if( (*iter)->getId() == mediaStream->getId() ) {
+ if( (*iter)->getId() == realtimeMediaStream->getId() ) {
found = true;
#ifdef DEBUG_OUTPUT
- cerr << "RtpRcvr::registerMediaStream: media stream already registered. Updating MRef." << endl;
+ cerr << "RtpRcvr::registerRealtimeMediaStream: media stream already registered. Updating MRef." << endl;
#endif
- (*iter) = mediaStream;
+ (*iter) = realtimeMediaStream;
break;
}
}
if( !found ) {
- mediaStreams.push_back( mediaStream );
+ realtimeMediaStreams.push_back( realtimeMediaStream );
}
}
- mediaStreamsLock.unlock();
+ realtimeMediaStreamsLock.unlock();
}
-void RtpReceiver::unregisterMediaStream( MRef<MediaStreamReceiver *> mediaStream ){
+void RtpReceiver::unregisterRealtimeMediaStream( MRef<RealtimeMediaStreamReceiver *> realtimeMediaStream ){
#ifdef DEBUG_OUTPUT
- // cerr << "RtpReceiver::unregisterMediaStream: Before taking lock" << endl;
+ // cerr << "RtpReceiver::unregisterRealtimeMediaStream: Before taking lock" << endl;
#endif
- mediaStreamsLock.lock();
- mediaStreams.remove( mediaStream );
- if( mediaStreams.size() == 0 ){
+ realtimeMediaStreamsLock.lock();
+ realtimeMediaStreams.remove( realtimeMediaStream );
+ if( realtimeMediaStreams.size() == 0 ){
/* End the thread */
kill = true;
}
- mediaStreamsLock.unlock();
+ realtimeMediaStreamsLock.unlock();
#ifdef DEBUG_OUTPUT
- // cerr << "RtpReceiver::unregisterMediaStream: After taking lock" << endl;
+ // cerr << "RtpReceiver::unregisterRealtimeMediaStream: After taking lock" << endl;
#endif
}
@@ -193,7 +193,7 @@
MRef<SRtpPacket *> packet;
while( !kill ){
- list< MRef<MediaStreamReceiver *> >::iterator i;
+ list< MRef<RealtimeMediaStreamReceiver *> >::iterator i;
fd_set rfds;
struct timeval tv;
int ret = -1;
@@ -233,9 +233,9 @@
}
if( ret == 0 /* timeout */ ){
- //notify the mediaStreams of the timeout
- for( i = mediaStreams.begin();
- i != mediaStreams.end(); i++ ){
+ //notify the RealtimeMediaStreams of the timeout
+ for( i = realtimeMediaStreams.begin();
+ i != realtimeMediaStreams.end(); i++ ){
(*i)->handleRtpPacket( NULL, callId, NULL );
}
continue;
@@ -253,8 +253,8 @@
continue;
}
- mediaStreamsLock.lock();
- for ( i = mediaStreams.begin(); i != mediaStreams.end(); i++ ) {
+ realtimeMediaStreamsLock.lock();
+ for ( i = realtimeMediaStreams.begin(); i != realtimeMediaStreams.end(); i++ ) {
std::list<MRef<Codec *> > codecs = (*i)->getAvailableCodecs();
std::list<MRef<Codec *> >::iterator iC;
int found = 0;
@@ -283,7 +283,7 @@
}
#endif // ZRTP_SUPPORT
}
- mediaStreamsLock.unlock();
+ realtimeMediaStreamsLock.unlock();
packet = NULL;
}
Modified: trunk/libminisip/source/subsystem_media/Session.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/Session.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/Session.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -291,74 +291,27 @@
return result;
}
-MRef<SdpPacket *> Session::getSdpOffer( const string &peerUri, bool anatSupported ){ // used by the initiator when creating the first message
- MRef<SdpPacket *> result;
- list< MRef<MediaStreamReceiver *> >::iterator i;
+bool Session::addRealtimeMediaToOffer(MRef<SdpPacket*> result, const string &peerUri, bool anatSupported, string transport){
+ list< MRef<RealtimeMediaStreamReceiver *> >::iterator i;
std::list<std::string>::iterator iAttribute;
std::list<std::string> attributes;
string type;
uint16_t localPort = 0;
MRef<SdpHeaderM *> m;
- string keyMgmtMessage;
std::list<MRef<Codec *> > codecs;
std::list<MRef<Codec *> >::iterator iC;
uint8_t payloadType;
string rtpmap;
- const char *transport = NULL;
bool anat = false;
// cerr << "Session::getSdpOffer" << endl;
- result = emptySdp();
- if( identity->securityEnabled ){
- int type = 0;
- // FIXME
- switch( ka_type ){
- case KEY_MGMT_METHOD_MIKEY_DH:
- type = KEY_AGREEMENT_TYPE_DH;
- break;
- case KEY_MGMT_METHOD_MIKEY_PSK:
- type = KEY_AGREEMENT_TYPE_PSK;
- break;
- case KEY_MGMT_METHOD_MIKEY_PK:
- type = KEY_AGREEMENT_TYPE_PK;
- break;
- case KEY_MGMT_METHOD_MIKEY_DHHMAC:
- type = KEY_AGREEMENT_TYPE_DHHMAC;
- break;
- case KEY_MGMT_METHOD_MIKEY_RSA_R:
- type = KEY_AGREEMENT_TYPE_RSA_R;
- break;
- default:
- mikey = NULL;
- return NULL;
- }
-
- MRef<SdpHeaderA *> a;
- MikeyConfig *config = new MikeyConfig( identity );
- // FIXME free config
- mikey = new Mikey( config );
-
- addStreams();
-
- keyMgmtMessage = mikey->initiatorCreate( type, peerUri );
- if( mikey->error() ){
- // something went wrong
- return NULL;
- }
- result->setSessionLevelAttribute( "key-mgmt", keyMgmtMessage );
- transport = "RTP/SAVP";
- }
- else{
- transport = "RTP/AVP";
- }
-
if( anatSupported && !localIpString.empty() && !localIp6String.empty() ){
anat = true;
result->setSessionLevelAttribute( "group", "ANAT 1 2" );
}
- for( i = mediaStreamReceivers.begin(); i != mediaStreamReceivers.end(); i++ ){
+ for( i = realtimeMediaStreamReceivers.begin(); i != realtimeMediaStreamReceivers.end(); i++ ){
codecs = (*i)->getAvailableCodecs();
type = (*i)->getSdpMediaType();
@@ -448,13 +401,75 @@
#ifdef DEBUG_OUTPUT
cerr << "Session::getSdpOffer: " << endl << result->getString() << endl << endl;
#endif
+
+ return true;
+
+}
+
+
+MRef<SdpPacket *> Session::getSdpOffer( const string &peerUri, bool anatSupported ){ // used by the initiator when creating the first message
+ string keyMgmtMessage;
+ const char *transport = NULL;
+ MRef<SdpPacket *> result;
+
+ result = emptySdp();
+
+ if( identity->securityEnabled ){
+ int type = 0;
+
+ // FIXME
+ switch( ka_type ){
+ case KEY_MGMT_METHOD_MIKEY_DH:
+ type = KEY_AGREEMENT_TYPE_DH;
+ break;
+ case KEY_MGMT_METHOD_MIKEY_PSK:
+ type = KEY_AGREEMENT_TYPE_PSK;
+ break;
+ case KEY_MGMT_METHOD_MIKEY_PK:
+ type = KEY_AGREEMENT_TYPE_PK;
+ break;
+ case KEY_MGMT_METHOD_MIKEY_DHHMAC:
+ type = KEY_AGREEMENT_TYPE_DHHMAC;
+ break;
+ case KEY_MGMT_METHOD_MIKEY_RSA_R:
+ type = KEY_AGREEMENT_TYPE_RSA_R;
+ break;
+ default:
+ mikey = NULL;
+ return false;
+ }
+
+ MRef<SdpHeaderA *> a;
+ MikeyConfig *config = new MikeyConfig( identity );
+ // FIXME free config
+ mikey = new Mikey( config );
+
+ addStreams();
+
+ keyMgmtMessage = mikey->initiatorCreate( type, peerUri );
+ if( mikey->error() ){
+ // something went wrong
+ return false;
+ }
+ result->setSessionLevelAttribute( "key-mgmt", keyMgmtMessage );
+ transport = "RTP/SAVP";
+ }
+ else{
+ transport = "RTP/AVP";
+ }
+
+
+
+ if (!addRealtimeMediaToOffer(result, peerUri, anatSupported, transport)){
+ return NULL;
+ }
return result;
}
bool Session::setSdpAnswer( MRef<SdpPacket *> answer, string peerUri ){
unsigned int i;
int j;
- MRef<MediaStreamReceiver *> receiver;
+ MRef<RealtimeMediaStreamReceiver *> receiver;
bool found = false;
this->peerUri = peerUri;
@@ -566,17 +581,17 @@
return found;
}
-MRef<MediaStreamReceiver *> Session::matchFormat( MRef<SdpHeaderM *> m, uint32_t iFormat, MRef<IPAddress *> &remoteAddress ){
- list< MRef<MediaStreamSender *> >::iterator iSStream;
- list< MRef<MediaStreamReceiver *> >::iterator iRStream;
+MRef<RealtimeMediaStreamReceiver *> Session::matchFormat( MRef<SdpHeaderM *> m, uint32_t iFormat, MRef<IPAddress *> &remoteAddress ){
+ list< MRef<RealtimeMediaStreamSender *> >::iterator iSStream;
+ list< MRef<RealtimeMediaStreamReceiver *> >::iterator iRStream;
/* If we have a sender for this format, activate it */
#ifdef DEBUG_OUTPUT
mdbg("media") << "Session::matchFormat: Starting senders loop" << endl;
#endif
uint8_t j = 1;
- mediaStreamSendersLock.lock();
- for( iSStream = mediaStreamSenders.begin(); iSStream != mediaStreamSenders.end(); iSStream++,j++ ){
+ realtimeMediaStreamSendersLock.lock();
+ for( iSStream = realtimeMediaStreamSenders.begin(); iSStream != realtimeMediaStreamSenders.end(); iSStream++,j++ ){
#ifdef DEBUG_OUTPUT
mdbg("media") << "Trying a sender"<< endl;
#endif
@@ -603,12 +618,12 @@
(*iSStream)->setRemoteAddress( remoteAddress );
}
}
- mediaStreamSendersLock.unlock();
+ realtimeMediaStreamSendersLock.unlock();
/* Look for a receiver */
#ifdef DEBUG_OUTPUT
mdbg("media") << "Starting receivers loop"<< endl;
#endif
- for( iRStream = mediaStreamReceivers.begin(); iRStream != mediaStreamReceivers.end(); iRStream ++ ){
+ for( iRStream = realtimeMediaStreamReceivers.begin(); iRStream != realtimeMediaStreamReceivers.end(); iRStream ++ ){
if( (*iRStream)->matches( m, iFormat ) ){
#ifdef DEBUG_OUTPUT
mdbg("media") << "Found receiver for " << (*iRStream)->getSdpMediaType()<< endl;
@@ -623,7 +638,7 @@
bool Session::setSdpOffer( MRef<SdpPacket *> offer, string peerUri ){ // used by the responder when receiving the first message
unsigned int i;
int j;
- MRef<MediaStreamReceiver *> receiver;
+ MRef<RealtimeMediaStreamReceiver *> receiver;
MRef<SdpPacket *> packet;
string keyMgmtMessage;
std::list<std::string>::iterator iAttribute;
@@ -644,7 +659,7 @@
// FIXME free config
mikey = new Mikey( config );
- addStreams();
+ addStreams(); //TODO: This only adds SRTP streams, no reliable media is handled.
if( !mikey->responderAuthenticate( keyMgmtMessage, peerUri ) ){
errorString = "Incoming key management message could not be authenticated";
@@ -823,8 +838,8 @@
return;
started=true;
- list< MRef<MediaStreamSender * > >::iterator iS;
- list< MRef<MediaStreamReceiver * > >::iterator iR;
+ list< MRef<RealtimeMediaStreamSender * > >::iterator iS;
+ list< MRef<RealtimeMediaStreamReceiver * > >::iterator iR;
MRef<KeyAgreement*> ka;
@@ -846,7 +861,7 @@
#endif
}
- for( iR = mediaStreamReceivers.begin(); iR != mediaStreamReceivers.end(); iR++ ){
+ for( iR = realtimeMediaStreamReceivers.begin(); iR != realtimeMediaStreamReceivers.end(); iR++ ){
if( ! (*iR)->disabled ){
if( ka ){
(*iR)->setKeyAgreement( ka );
@@ -855,8 +870,8 @@
}
}
- mediaStreamSendersLock.lock();
- for( iS = mediaStreamSenders.begin(); iS != mediaStreamSenders.end(); iS++ ){
+ realtimeMediaStreamSendersLock.lock();
+ for( iS = realtimeMediaStreamSenders.begin(); iS != realtimeMediaStreamSenders.end(); iS++ ){
if( (*iS)->getPort() ){
if( ka ){
(*iS)->setKeyAgreement( ka );
@@ -868,22 +883,22 @@
MRef<CallRecorder *> cr = dynamic_cast<CallRecorder *>(*callRecorder);
cr->setEnabled( f
}*/
- mediaStreamSendersLock.unlock();
+ realtimeMediaStreamSendersLock.unlock();
}
void Session::stop(){
started=false;
- list< MRef<MediaStreamSender * > >::iterator iS;
- list< MRef<MediaStreamReceiver * > >::iterator iR;
+ list< MRef<RealtimeMediaStreamSender * > >::iterator iS;
+ list< MRef<RealtimeMediaStreamReceiver * > >::iterator iR;
- for( iR = mediaStreamReceivers.begin(); iR != mediaStreamReceivers.end(); iR++ ){
+ for( iR = realtimeMediaStreamReceivers.begin(); iR != realtimeMediaStreamReceivers.end(); iR++ ){
if( ! (*iR)->disabled ){
(*iR)->stop();
}
}
- mediaStreamSendersLock.lock();
- for( iS = mediaStreamSenders.begin(); iS != mediaStreamSenders.end(); iS++ ){
+ realtimeMediaStreamSendersLock.lock();
+ for( iS = realtimeMediaStreamSenders.begin(); iS != realtimeMediaStreamSenders.end(); iS++ ){
if( (*iS)->getPort() ){
(*iS)->stop();
}
@@ -899,21 +914,21 @@
}
callRecorder = NULL; //stop the call recorder object
- mediaStreamSendersLock.unlock();
+ realtimeMediaStreamSendersLock.unlock();
}
-void Session::addMediaStreamReceiver( MRef<MediaStreamReceiver *> mediaStream ){
- mediaStreamReceivers.push_back( *mediaStream );
+void Session::addRealtimeMediaStreamReceiver( MRef<RealtimeMediaStreamReceiver *> realtimeMediaStream ){
+ realtimeMediaStreamReceivers.push_back( *realtimeMediaStream );
silenceSources( silencedSources );
}
-void Session::addMediaStreamSender( MRef<MediaStreamSender *> mediaStream ){
- mediaStreamSendersLock.lock();
- mediaStream->setMuted( mutedSenders );
- mediaStreamSenders.push_back( *mediaStream );
- mediaStreamSendersLock.unlock();
+void Session::addRealtimeMediaStreamSender( MRef<RealtimeMediaStreamSender *> realtimeMediaStream ){
+ realtimeMediaStreamSendersLock.lock();
+ realtimeMediaStream->setMuted( mutedSenders );
+ realtimeMediaStreamSenders.push_back( *realtimeMediaStream );
+ realtimeMediaStreamSendersLock.unlock();
}
string Session::getErrorString(){
@@ -936,15 +951,15 @@
void Session::setCallId( const string callId ){
this->callId = callId;
#ifdef ZRTP_SUPPORT
- mediaStreamSendersLock.lock();
- for ( std::list< MRef<MediaStreamSender *> >::iterator it = mediaStreamSenders.begin();
- it != mediaStreamSenders.end(); it++ ) { // TODO - need better support to set call id in ZHB
+ realtimeMediaStreamSendersLock.lock();
+ for ( std::list< MRef<RealtimeMediaStreamSender *> >::iterator it = realtimeMediaStreamSenders.begin();
+ it != realtimeMediaStreamSenders.end(); it++ ) { // TODO - need better support to set call id in ZHB
MRef<ZrtpHostBridgeMinisip*> zhb = (*it)->getZrtpHostBridge();
if (zhb) {
zhb->setCallId(callId);
}
}
- mediaStreamSendersLock.unlock();
+ realtimeMediaStreamSendersLock.unlock();
#endif
}
@@ -965,9 +980,9 @@
void Session::muteSenders (bool mute) {
mutedSenders = mute;
- mediaStreamSendersLock.lock();
- for( std::list< MRef<MediaStreamSender *> >::iterator it = mediaStreamSenders.begin();
- it != mediaStreamSenders.end(); it++ ) {
+ realtimeMediaStreamSendersLock.lock();
+ for( std::list< MRef<RealtimeMediaStreamSender *> >::iterator it = realtimeMediaStreamSenders.begin();
+ it != realtimeMediaStreamSenders.end(); it++ ) {
(*it)->setMuted( mute );
}
@@ -984,7 +999,7 @@
cr->setEnabledMic( !mute );
}
- mediaStreamSendersLock.unlock();
+ realtimeMediaStreamSendersLock.unlock();
}
void Session::silenceSources ( bool silence ) {
@@ -996,8 +1011,8 @@
*/
#endif
silencedSources = silence;
- for( std::list< MRef<MediaStreamReceiver *> >::iterator it = mediaStreamReceivers.begin();
- it != mediaStreamReceivers.end(); it++ ) {
+ for( std::list< MRef<RealtimeMediaStreamReceiver *> >::iterator it = realtimeMediaStreamReceivers.begin();
+ it != realtimeMediaStreamReceivers.end(); it++ ) {
list<uint32_t> ssrcList;
list<uint32_t>::iterator ssrcIt;
MRef<AudioMedia *> audioMedia;
@@ -1068,20 +1083,20 @@
}else
ret += "\n (no call recorder)";
- for( std::list< MRef<MediaStreamReceiver *> >::iterator it = mediaStreamReceivers.begin();
- it != mediaStreamReceivers.end(); it++ ) {
+ for( std::list< MRef<RealtimeMediaStreamReceiver *> >::iterator it = realtimeMediaStreamReceivers.begin();
+ it != realtimeMediaStreamReceivers.end(); it++ ) {
ret += "\n " + (*it)->getDebugString();
}
- for( std::list< MRef<MediaStreamSender *> >::iterator it2 = mediaStreamSenders.begin();
- it2 != mediaStreamSenders.end(); it2++ ) {
+ for( std::list< MRef<RealtimeMediaStreamSender *> >::iterator it2 = realtimeMediaStreamSenders.begin();
+ it2 != realtimeMediaStreamSenders.end(); it2++ ) {
ret += "\n " + (*it2)->getDebugString();
}
return ret;
}
#endif
-void Session::clearMediaStreamReceivers() {
- mediaStreamReceivers.clear();
+void Session::clearRealtimeMediaStreamReceivers() {
+ realtimeMediaStreamReceivers.clear();
}
const std::string &Session::getPeerUri() const{
@@ -1089,10 +1104,10 @@
}
void Session::addStreams() {
- MediaStreamSenders::iterator i;
- MediaStreamSenders::iterator last = mediaStreamSenders.end();
+ RealtimeMediaStreamSenders::iterator i;
+ RealtimeMediaStreamSenders::iterator last = realtimeMediaStreamSenders.end();
- for( i = mediaStreamSenders.begin(); i != last; i++ ){
+ for( i = realtimeMediaStreamSenders.begin(); i != last; i++ ){
uint32_t ssrc = (*i)->getSsrc();
mikey->addSender( ssrc );
}
Modified: trunk/libminisip/source/subsystem_media/Session.h
===================================================================
--- trunk/libminisip/source/subsystem_media/Session.h 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/Session.h 2007-12-13 12:18:12 UTC (rev 3553)
@@ -37,15 +37,15 @@
#include<libminisip/media/MediaStream.h>
#include<libmsip/SipDialogConfig.h>
-class MediaStreamReceiver;
-class MediaStreamSender;
+class RealtimeMediaStreamReceiver;
+class RealtimeMediaStreamSender;
class SdpHeaderM;
class IPAddress;
class SessionRegistry;
/**
* The session class is a representation of the media session associated
- * with a VoIP call. It holds MediaStreams that handles incoming and
+ * with a VoIP call. It holds RealtimeMediaStreams that handles incoming and
* outgoing streams for a given medium. The session is also the interface
* used by the SIP stack to send and receive session descriptions (SDP)
* and to start or stop the media transmission
@@ -123,20 +123,20 @@
bool setSdpOffer ( MRef<SdpPacket *> offer, std::string peerUri );
/**
- * Adds a MediaStreamReceiver to this media session. Used
+ * Adds a RealtimeMediaStreamReceiver to this media session. Used
* by the media handler to add a media stream per
* available medium.
- * @param r a reference to the MediaStreamReceiver object to add
+ * @param r a reference to the RealtimeMediaStreamReceiver object to add
*/
- void addMediaStreamReceiver( MRef<MediaStreamReceiver *> r );
+ void addRealtimeMediaStreamReceiver( MRef<RealtimeMediaStreamReceiver *> r );
/**
- * Adds a MediaStreamSender to this media session. Used
+ * Adds a RealtimeMediaStreamSender to this media session. Used
* by the media handler to add a media stream per
* available medium.
- * @param s a reference to the MediaStreamSender object to add
+ * @param s a reference to the RealtimeMediaStreamSender object to add
*/
- void addMediaStreamSender( MRef<MediaStreamSender *> s );
+ void addRealtimeMediaStreamSender( MRef<RealtimeMediaStreamSender *> s );
/**
* Returns an error description suitable for use
@@ -204,7 +204,7 @@
/**
Used to silence all the sources associated to this
Session. SoundSources receive the audio from the
- MediaStreamReceiver and act as a buffer. They are identified
+ RealtimeMediaStreamReceiver and act as a buffer. They are identified
by the ssrc (SoundSource::getId)
@param silence whether or not we want the sources silenced
*/
@@ -228,20 +228,20 @@
/**
Empty the media stream receivers list.
*/
- void clearMediaStreamReceivers();
+ void clearRealtimeMediaStreamReceivers();
/**
Return a copy of the list to the media stream receivers
*/
- std::list< MRef<MediaStreamReceiver *> > getMediaStreamReceivers() {
- return mediaStreamReceivers;
+ std::list< MRef<RealtimeMediaStreamReceiver *> > getRealtimeMediaStreamReceivers() {
+ return realtimeMediaStreamReceivers;
}
/**
Return a copy of the list to the media stream senders
*/
- std::list< MRef<MediaStreamSender *> > getMediaStreamSenders() {
- return mediaStreamSenders;
+ std::list< MRef<RealtimeMediaStreamSender *> > getRealtimeMediaStreamSenders() {
+ return realtimeMediaStreamSenders;
}
/**
@@ -256,6 +256,12 @@
MRef<MObject *> callRecorder;
private:
+ /**
+ * @return false if there was an error, and the result sdp
+ * packet can not be used.
+ */
+ bool addRealtimeMediaToOffer(MRef<SdpPacket*> result, const std::string &peerUri, bool anatSupported, std::string transport);
+
bool started;
void addStreams();
@@ -263,13 +269,13 @@
MRef<SdpPacket *> emptySdp();
- MRef<MediaStreamReceiver *> matchFormat( MRef<SdpHeaderM *> m,
+ MRef<RealtimeMediaStreamReceiver *> matchFormat( MRef<SdpHeaderM *> m,
uint32_t iFormat, MRef<IPAddress *> &remoteAddress );
- typedef std::list< MRef<MediaStreamSender *> > MediaStreamSenders;
- std::list< MRef<MediaStreamReceiver *> > mediaStreamReceivers;
- std::list< MRef<MediaStreamSender *> > mediaStreamSenders;
- Mutex mediaStreamSendersLock;
+ typedef std::list< MRef<RealtimeMediaStreamSender *> > RealtimeMediaStreamSenders;
+ std::list< MRef<RealtimeMediaStreamReceiver *> > realtimeMediaStreamReceivers;
+ std::list< MRef<RealtimeMediaStreamSender *> > realtimeMediaStreamSenders;
+ Mutex realtimeMediaStreamSendersLock;
MRef<Mikey *> mikey;
std::string localIpString;
Modified: trunk/libminisip/source/subsystem_media/soundcard/SoundIO.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/soundcard/SoundIO.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/soundcard/SoundIO.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -189,7 +189,7 @@
// for G711+ilbc.
}
-void SoundIO::unRegisterRecorderReceiver( SoundRecorderCallback *callback ) {
+void SoundIO::unregisterRecorderReceiver( SoundRecorderCallback *callback ) {
list<RecorderReceiver *>::iterator iter;
for( iter = recorder_callbacks.begin();
iter != recorder_callbacks.end();
@@ -361,10 +361,10 @@
}
-void SoundIO::unRegisterSource(int sourceId){
+void SoundIO::unregisterSource(int sourceId){
#ifdef DEBUG_OUTPUT
- cerr << "SoundIO::unRegisterSource - Calling unRegister source on source " << sourceId << endl;
+ cerr << "SoundIO::unregisterSource - Calling unregister source on source " << sourceId << endl;
#endif
queueLock.lock();
list<MRef<SoundSource *> >::iterator i;
Modified: trunk/libminisip/source/subsystem_media/video/VideoMedia.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/video/VideoMedia.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/video/VideoMedia.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -139,7 +139,7 @@
}
-void VideoMedia::unRegisterMediaSource( uint32_t ssrc ){
+void VideoMedia::unregisterMediaSource( uint32_t ssrc ){
MRef<VideoMediaSource *> source = getSource( ssrc );
if( source ){
@@ -173,7 +173,7 @@
return NULL;
}
-void VideoMedia::registerMediaSender( MRef<MediaStreamSender *> sender ){
+void VideoMedia::registerMediaSender( MRef<RealtimeMediaStreamSender *> sender ){
sendersLock.lock();
if( senders.size() == 0 ){
sendersLock.unlock();
@@ -186,7 +186,7 @@
}
-void VideoMedia::unRegisterMediaSender( MRef<MediaStreamSender *> sender ){
+void VideoMedia::unregisterMediaSender( MRef<RealtimeMediaStreamSender *> sender ){
sendersLock.lock();
senders.remove( sender );
sendersLock.unlock();
Modified: trunk/libminisip/source/subsystem_media/zrtp/ZrtpHostBridgeMinisip.cxx
===================================================================
--- trunk/libminisip/source/subsystem_media/zrtp/ZrtpHostBridgeMinisip.cxx 2007-12-12 14:54:59 UTC (rev 3552)
+++ trunk/libminisip/source/subsystem_media/zrtp/ZrtpHostBridgeMinisip.cxx 2007-12-13 12:18:12 UTC (rev 3553)
@@ -82,11 +82,11 @@
delete zrtpEngine;
}
-void ZrtpHostBridgeMinisip::setReceiver(MRef<MediaStreamReceiver *> r) {
+void ZrtpHostBridgeMinisip::setReceiver(MRef<RealtimeMediaStreamReceiver *> r) {
rStream = r;
}
-void ZrtpHostBridgeMinisip::setSender(MRef<MediaStreamSender *> s) {
+void ZrtpHostBridgeMinisip::setSender(MRef<RealtimeMediaStreamSender *> s) {
sStream = s;
}
More information about the Minisip-devel
mailing list